What will I actually learn in this design patterns course?

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.

Do I need to know Java before taking this course?

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.

Is this course beginner-friendly for design patterns?

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.

How long does it take to complete this course?

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.

Are there hands-on exercises or projects in this course?

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.

What skills and topics are covered in this course?

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.

What can I actually do after finishing this course?

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.

Is this course more focused on theory or hands-on learning?

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.

Why would I choose this course over other design patterns courses?

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.

Design Patterns

Design Patterns

This course is part of Software Design and Architecture Specialization

Instructor: Kenny Wong

104,978 already enrolled

Included with

Learn more

4 modules

Gain insight into a topic and learn the fundamentals.

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

4 modules

Gain insight into a topic and learn the fundamentals.

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

Skills you'll gain

Tools you'll learn

Details to know

Shareable certificate

Add to your LinkedIn profile

Assessments

4 assignments¹

AI Graded see disclaimer

Taught in English

See how employees at top companies are mastering in-demand skills

Learn more about Coursera for Business

logos of Petrobras, TATA, Danone, Capgemini, P&G and L'Oreal

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.

Module details

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 videosTotal 66 minutes

2.1.1 – What is a Design Pattern?7 minutes
2.1.2 – Creational, Structural, and Behavioural Patterns6 minutes
2.1.3 – Singleton Pattern5 minutes
2.1.4 – Factory Method Pattern11 minutes
2.1.5 – Facade Pattern6 minutes
2.1.6 – Adapter Pattern5 minutes
2.1.7 – Composite Pattern6 minutes
2.1.8 – Proxy Pattern7 minutes
2.1.9 – Decorator Pattern11 minutes

8 readingsTotal 80 minutes

Meet Your Presenter – Sam Jeffery10 minutes
Meet Your Facilitator– Cecilia Xiang10 minutes
Discussion: Introduce Yourself10 minutes
Discussion: Design Pattern Examples10 minutes
Design Patterns Course Notes - Updated July 202110 minutes
Design Patterns Glossary10 minutes
Ungraded Assignment - Adapter Pattern (Solution)10 minutes
Ungraded Assignment - Composite Pattern (Solution)10 minutes

1 assignmentTotal 30 minutes

Module 1 Review30 minutes

2 peer reviewsTotal 120 minutes

Ungraded Assignment – Adapter Pattern60 minutes
Ungraded Assessment – Composite Pattern60 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 videosTotal 33 minutes

2.2.1 – Template Method Pattern7 minutes
2.2.2 – Chain of Responsibility Pattern6 minutes
2.2.3 – State Pattern6 minutes
2.2.4 – Command Pattern9 minutes
2.2.5 – Observer Pattern6 minutes

5 readingsTotal 50 minutes

Discussion: Undo/Redo As a Pattern10 minutes
Mediator Pattern10 minutes
Peer Review Request Forum10 minutes
Capstone Assignment 2.1 - Implement the Command Pattern (Solution)10 minutes
Ungraded Assignment - Observer Pattern (Solution)10 minutes

1 assignmentTotal 30 minutes

Module 2 Review30 minutes

2 peer reviewsTotal 120 minutes

Capstone Assignment 2.1– Implement the Command Pattern60 minutes
Ungraded Assignment – Observer Pattern60 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 videosTotal 62 minutes

2.3.1 – MVC Pattern9 minutes
2.3.2 – Open/Closed Principle5 minutes
2.3.3 – Dependency Inversion Principle6 minutes
2.3.4 – Composing Objects Principle5 minutes
2.3.5 – Interface Segregation Principle5 minutes
2.3.6 – Principle of Least Knowledge7 minutes
2.3.7 – Part 1 - Code Smells11 minutes
2.3.7 – Part 2 - Code Smells13 minutes

4 readingsTotal 40 minutes

Ungraded Assignment - MVC Pattern (Solution)10 minutes
Capstone Assignment 2.2 - Implement MVC Pattern (Solution)10 minutes
Liskov Substitution Principle10 minutes
Discussion: Stories of Bad Coding10 minutes

1 assignmentTotal 30 minutes

Module 3 Review30 minutes

2 peer reviewsTotal 120 minutes

Capstone Assignment 2.2 – Implement MVC Pattern60 minutes
Ungraded Assignment – MVC Pattern60 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

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

(229 ratings)

Kenny Wong

University of Alberta

12 Courses481,276 learners

Offered by

University of Alberta

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

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.

Reviewed on Jun 29, 2023

An awesome and thorough introduction to design patterns. The assignments helped very much with implementing them in a real world application. Thankyou everyone involved in this course.

Reviewed on Aug 24, 2021

Wonderful course. It can enhance tour knowledge and give opportunity to explore more about design patterns. There are wonderful examples, assignments and quiz. I would highly recommend this course.

View more reviews