VOOZH about

URL: https://www.coursera.org/learn/design-patterns

⇱ Design Patterns | Coursera


Keep adding new skills with 10,000+ programs for $239 (usually $399). Save now.

Design Patterns

105,250 already enrolled

Included with

β€’

Learn more

Ask Coursera

Gain insight into a topic and learn the fundamentals.
4.7

1,375 reviews

Intermediate level
Some related experience required
Flexible schedule
2 weeks at 10 hours a week
Learn at your own pace
91%
Most learners liked this course

Gain insight into a topic and learn the fundamentals.
4.7

1,375 reviews

Intermediate level
Some related experience required
Flexible schedule
2 weeks at 10 hours a week
Learn at your own pace
91%
Most learners liked this course

Build your subject-matter expertise

This course is part of the Software Design and Architecture Specialization
When you enroll in this course, you'll also be enrolled in this Specialization.
  • Learn new concepts from industry experts
  • Gain a foundational understanding of a subject or tool
  • Develop job-relevant skills with hands-on projects
  • Earn a shareable career certificate

There are 4 modules in this course

This course extends object-oriented analysis and design by incorporating design patterns to create interactive applications. Through a survey of established design patterns, you will gain a foundation for more complex software applications. Finally, you will identify problematic software designs by referencing a catalog of code smells.

You will be challenged in the Capstone Project to redesign an existing Java-based Android application to implement a combination of design patterns. You will also critique a given Java codebase for code smells. After completing this course, you will be able to: β€’ Demonstrate how to use design patterns to address user interface design issues. β€’ Identify the most suitable design pattern to address a given application design problem. β€’ Apply design principles (e.g., open-closed, dependency inversion, least knowledge). β€’ Critique code by identifying and refactoring anti-patterns. β€’ Apply the model-view-controller architectural pattern.

Design patterns help to solve common design issues in object-oriented software. You will learn what they are and how they can be applied. In this module you will learn the creational and structural design patterns. You will continue to learn and practice expressing designs in UML, and code some of these patterns in Java.

What's included

9 videos8 readings1 assignment2 peer reviews

9 videosβ€’Total 66 minutes
  • 2.1.1 – What is a Design Pattern?β€’7 minutes
  • 2.1.2 – Creational, Structural, and Behavioural Patternsβ€’6 minutes
  • 2.1.3 – Singleton Patternβ€’5 minutes
  • 2.1.4 – Factory Method Patternβ€’11 minutes
  • 2.1.5 – Facade Patternβ€’6 minutes
  • 2.1.6 – Adapter Patternβ€’5 minutes
  • 2.1.7 – Composite Patternβ€’6 minutes
  • 2.1.8 – Proxy Patternβ€’7 minutes
  • 2.1.9 – Decorator Patternβ€’11 minutes
8 readingsβ€’Total 80 minutes
  • Meet Your Presenter – Sam Jefferyβ€’10 minutes
  • Meet Your Facilitator– Cecilia Xiangβ€’10 minutes
  • Discussion: Introduce Yourselfβ€’10 minutes
  • Discussion: Design Pattern Examplesβ€’10 minutes
  • Design Patterns Course Notes - Updated July 2021β€’10 minutes
  • Design Patterns Glossaryβ€’10 minutes
  • Ungraded Assignment - Adapter Pattern (Solution)β€’10 minutes
  • Ungraded Assignment - Composite Pattern (Solution)β€’10 minutes
1 assignmentβ€’Total 30 minutes
  • Module 1 Reviewβ€’30 minutes
2 peer reviewsβ€’Total 120 minutes
  • Ungraded Assignment – Adapter Patternβ€’60 minutes
  • Ungraded Assessment – Composite Patternβ€’60 minutes

You will continue learning useful design patterns and add them to your toolbox. In this module, you will learn the behavioural patterns. This will include communicating them in UML and coding them in Java!

What's included

5 videos5 readings1 assignment2 peer reviews

5 videosβ€’Total 33 minutes
  • 2.2.1 – Template Method Patternβ€’7 minutes
  • 2.2.2 – Chain of Responsibility Patternβ€’6 minutes
  • 2.2.3 – State Patternβ€’6 minutes
  • 2.2.4 – Command Patternβ€’9 minutes
  • 2.2.5 – Observer Patternβ€’6 minutes
5 readingsβ€’Total 50 minutes
  • Discussion: Undo/Redo As a Patternβ€’10 minutes
  • Mediator Patternβ€’10 minutes
  • Peer Review Request Forumβ€’10 minutes
  • Capstone Assignment 2.1 - Implement the Command Pattern (Solution)β€’10 minutes
  • Ungraded Assignment - Observer Pattern (Solution)β€’10 minutes
1 assignmentβ€’Total 30 minutes
  • Module 2 Reviewβ€’30 minutes
2 peer reviewsβ€’Total 120 minutes
  • Ungraded Assignment – Observer Patternβ€’60 minutes
  • Capstone Assignment 2.1– Implement the Command Patternβ€’60 minutes

You will learn a design pattern that is very useful for user interfaces: model-view-controller, or MVC. Then you will learn some principles underlying the design patterns, to create software that is flexible, reusable, and maintainable. Finally, you will learn some of the symptoms of bad design, which we call code smells or antipatterns.

What's included

8 videos4 readings1 assignment2 peer reviews

8 videosβ€’Total 62 minutes
  • 2.3.1 – MVC Patternβ€’9 minutes
  • 2.3.2 – Open/Closed Principleβ€’5 minutes
  • 2.3.3 – Dependency Inversion Principleβ€’6 minutes
  • 2.3.4 – Composing Objects Principleβ€’5 minutes
  • 2.3.5 – Interface Segregation Principleβ€’5 minutes
  • 2.3.6 – Principle of Least Knowledgeβ€’7 minutes
  • 2.3.7 – Part 1 - Code Smellsβ€’11 minutes
  • 2.3.7 – Part 2 - Code Smellsβ€’13 minutes
4 readingsβ€’Total 40 minutes
  • Ungraded Assignment - MVC Pattern (Solution)β€’10 minutes
  • Capstone Assignment 2.2 - Implement MVC Pattern (Solution)β€’10 minutes
  • Liskov Substitution Principleβ€’10 minutes
  • Discussion: Stories of Bad Codingβ€’10 minutes
1 assignmentβ€’Total 30 minutes
  • Module 3 Reviewβ€’30 minutes
2 peer reviewsβ€’Total 120 minutes
  • Ungraded Assignment – MVC Patternβ€’60 minutes
  • Capstone Assignment 2.2 – Implement MVC Patternβ€’60 minutes

In the previous modules, you were introduced to a variety of design patterns, and applied two of these to the example Android code base. Now, in the final module of the course, you will identify and fix specific code smells in this code base. After completing these tasks, you will be ready to complete the final exam.

What's included

4 readings1 assignment1 peer review

4 readingsβ€’Total 40 minutes
  • Capstone Assignment 2.3 - Identify and Fix Code Smells (Solution)β€’10 minutes
  • Discussion: Last Word – Design Patternsβ€’10 minutes
  • Acknowledgementsβ€’10 minutes
  • Creditsβ€’10 minutes
1 assignmentβ€’Total 30 minutes
  • Final Examβ€’30 minutes
1 peer reviewβ€’Total 60 minutes
  • Capstone Assignment 2.3 – Identify and Fix Code Smellsβ€’60 minutes

Earn a career certificate

Add this credential to your LinkedIn profile, resume, or CV. Share it on social media and in your performance review.

Instructor

Instructor ratings
4.6 (229 ratings)
University of Alberta
12 Coursesβ€’482,700 learners

Explore more from Software Development

Why people choose Coursera for their career

πŸ‘ Image

Felipe M.

Learner since 2018
"To be able to take courses at my own pace and rhythm has been an amazing experience. I can learn whenever it fits my schedule and mood."
πŸ‘ Image

Jennifer J.

Learner since 2020
"I directly applied the concepts and skills I learned from my courses to an exciting new project at work."
πŸ‘ Image

Larry W.

Learner since 2021
"When I need courses on topics that my university doesn't offer, Coursera is one of the best places to go."
πŸ‘ Image

Chaitanya A.

"Learning isn't just about being better at your job: it's so much more than that. Coursera allows me to learn without limits."

Learner reviews

  • 5 stars

    75.43%

  • 4 stars

    19.40%

  • 3 stars

    3.12%

  • 2 stars

    1.09%

  • 1 star

    0.94%

Showing 3 of 1375

BS
Β·

Reviewed on Jun 3, 2021

The concepts had a lucid articulation. The course covered most of the design patterns including design principles behind them. I found it very useful.

UK
Β·

Reviewed on Jan 23, 2022

Excellent course! Instructor easy description as well as lots examples helps me to solidify my object oriented and design pattern principles. Thank you so much for this course.

RJ
Β·

Reviewed on Mar 17, 2022

The course and the instructor was so good. The curriculum was well designed and of appropriate length. I really enjoyed and learnt skills that I would be able to apply while developing real software

Frequently asked questions

You'll learn how to choose and apply design patterns to improve object-oriented software, especially interactive applications. It starts with core pattern ideas in Java and UML, then builds into behavioral patterns, MVC, design principles, and code smells. By the end, you'll use those ideas to redesign parts of an existing Java-based Android app and critique a codebase for anti-patterns.

You don't need prior design patterns knowledge, but some Java and object-oriented programming familiarity will help. The course moves quickly into implementing patterns in Java, reading UML diagrams, and working with an existing codebase rather than teaching programming basics from scratch. Android experience is useful for later assignments, but the course provides a starter option recommended for learners without Android programming experience.

It can work if you're new to design patterns, but not if you're brand new to programming. The course is labeled intermediate and expects you to follow Java code, UML, and refactoring work from fairly early on. It fits best if you already understand object-oriented basics and want to level up your software design skills.

Plan on about 15 hours in total. At around 10 hours a week, that's roughly 1 to 2 weeks of work, depending on how much time you spend on the coding assignments and capstone tasks. The course includes lessons, readings, quizzes, and practice assignments, so the workload stays varied.

Yes, there is real hands-on work, but it's mostly guided rather than fully open-ended. You'll implement patterns in Java from UML diagrams and complete capstone assignments that apply ideas like the Command pattern or MVC to an existing app codebase. That practice helps you connect each pattern to an actual design problem instead of only learning the vocabulary.

The course covers major design pattern families, UML-based design communication, and the software design principles behind flexible code. You'll study creational, structural, and behavioral patterns, then use ideas like open-closed or dependency inversion when evaluating design choices. It also builds your ability to recognize code smells and think about refactoring more systematically.

After finishing, you should be able to match a design problem to an appropriate pattern and explain or implement that choice in Java. You should also be able to read and sketch UML for common patterns, reorganize code around MVC, and identify code smells that need refactoring. In practice, that means you can review an existing codebase and make targeted design improvements instead of only naming patterns from memory.

It's more concept-first, with guided coding practice throughout. The course spends a lot of time on when patterns and design principles make sense, then reinforces that through Java assignments, UML exercises, and capstone work.

Choose this course if you want design patterns taught as software design decisions, not just as a catalog to memorize. It connects pattern families with UML, MVC, design principles, and code smells, then asks you to apply them to an existing Java-based Android app and critique real code. If you're looking for an intermediate course that mixes explanation with guided redesign work, this is a good fit.

Financial aid available,

ΒΉ Some assignments in this course are AI-graded. For these assignments, your data will be used in accordance with Coursera's Privacy Notice.