Design Patterns
Keep adding new skills with 10,000+ programs for $239 (usually $399). Save now.
Design Patterns
This course is part of Software Design and Architecture Specialization
Instructor: Kenny Wong
105,250 already enrolled
Included with
Learn more
Ask Coursera
1,375 reviews
1,375 reviews
Skills you'll gain
Tools you'll learn
Details to know
See how employees at top companies are mastering in-demand skills
Build your subject-matter expertise
- 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
Offered by
Explore more from Software Development
- Status: Free TrialL
LearnKartS
Course
- Status: Free TrialU
University of Alberta
Course
- B
Birla Institute of Technology & Science, Pilani
Course
- Status: Free TrialU
University of Colorado Boulder
Course
Why people choose Coursera for their career
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 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.
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.
More questions
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.
