Design Patterns in Java (Udemy.com)
Discover the modern implementation of design patterns in Java
Created by: Dmitri Nesteruk
Last updated April 2020
Our take
Based on the ratings of 9,758 students, a sample of their written reviews and the syllabus, as the course stood in April 2020. No course pays to be reviewed.
Dmitri Nesteruk's course covers the SOLID principles and all the Gang of Four patterns in Java, taught as live coding in IntelliJ. The syllabus shows 123 lectures across 26 sections, about 10.5 hours, with a short section for each pattern and 22 coding exercises. It is written for working Java developers who already have solid object-oriented basics, not for newcomers. More than 63,000 students have taken it, and 9,758 ratings average 4.5.
Happy reviewers say the examples feel like code they might really write. One experienced Spring developer still uses it as a refresher, and several praise Dmitri's clear English and depth. The complaints are consistent, though. Examples are often more complicated than the pattern needs, and Adapter and Flyweight come up by name. People miss UML diagrams or any visuals, since the lessons are mostly screencast typing. A few say he talks fast, and some report exercise tests that break or a slow grader.
Most of the sample is four or five stars, so the majority leave satisfied. The last update was April 2020, and one reviewer calls some patterns partly deprecated. Another says Refactoring Guru has better examples. Reviewers' comments point to a strong reference for developers who can follow dense code, and a poor first look at patterns. If pictures and simple examples matter to you, pair it with a visual site.
Pros
- Covers SOLID plus all the GoF patterns, each in its own short section
- Hands-on format with 22 coding exercises and quizzes after the lessons
- Examples read like code people would use, per reviewers who liked it
- Instructor's English is clear and his depth is praised, even by an experienced Spring developer
Cons
- Examples are often more complex than the pattern, Adapter and Flyweight especially
- Almost no diagrams or UML, just screencast typing, and some find the pace fast
- Last updated April 2020, and the exercise grader has been slow or flaky
This is the best design pattern course i've seen. Most design pattern examples you can find in the internet are really weird and personally, i would not use them in my projects.
Intermediate is right: it expects solid Java and OO basics, and a beginner in the reviews found it hard to follow.
What you will learn
- Recognize and apply design patterns
- Refactor existing designs to use design patterns
- Reason about applicability and usability of design patterns
Course content
26 sections · 123 lectures · 11 hours of video 22 quizzes, 22 coding exercises, 1 article
- 1Introduction 1 free preview1 lecture · 5 min
- 2SOLID Design Principles 1 free preview7 lectures · 1.1 hours
- 3Builder 1 free preview8 lectures · 1 quiz · 43 min
- 4Factories5 lectures · 1 quiz · 30 min
- 5Prototype5 lectures · 1 quiz · 21 min
- 6Singleton12 lectures · 1 quiz · 1 hour
- 7Adapter4 lectures · 1 quiz · 20 min
- 8Bridge3 lectures · 1 quiz · 11 min
- 9Composite4 lectures · 1 quiz · 20 min
- 10Decorator6 lectures · 1 quiz · 31 min
- 11Façade3 lectures · 14 min
- 12Flyweight4 lectures · 1 quiz · 21 min
- 13Proxy 1 free preview6 lectures · 1 quiz · 25 min
- 14Chain of Responsibility 1 free preview5 lectures · 1 quiz · 31 min
- 15Command4 lectures · 1 quiz · 16 min
- 16Interpreter5 lectures · 1 quiz · 24 min
- 17Iterator4 lectures · 1 quiz · 25 min
- 18Mediator4 lectures · 1 quiz · 20 min
- 19Memento4 lectures · 1 quiz · 14 min
- 20Null Object4 lectures · 1 quiz · 16 min
- 21Observer5 lectures · 1 quiz · 23 min
- 22State5 lectures · 1 quiz · 32 min
- 23Strategy4 lectures · 1 quiz · 17 min
- 24Template Method3 lectures · 1 quiz · 9 min
- 25Visitor6 lectures · 1 quiz · 34 min
- 26Course Summary2 lectures · 1 min
Who it is for
The instructor says it suits
- Software engineers
- Designers
- Architects
What you need before you start
- Good understanding of Java
- Familiarity with latest Java features
- Good understanding of object-oriented design principles
- A computer with the latest JDK and (hopefully) an IDE
How it compares
Against the other 231 rated Udemy courses in Java on CourseDuck:
- Rating4.5 out of 5higher than 53% of them
- Reviews9,758#30 of 232 by number of reviews
- Length10.5 hourslonger than 54% of them
- Last updatedApril 2020earlier than 68% of them
Quality Score
Overall Score : 90 / 100
Course Description
Course Overview
This course provides a comprehensive overview of Design Patterns in Java from a practical perspective. This course in particular covers patterns with the use of:
The latest versions of the Java programming language
Use of modern programming approaches: dependency injection, reactive programming and more
Use of modern developer tools such as IntelliJ IDEA
Discussions of pattern variations and alternative approaches
This course provides an overview of all the Gang of Four (GoF) design patterns as outlined in their seminal book, together with modern-day variations, adjustments, discussions of intrinsic use of patterns in the language.
What are Design Patterns?
Design Patterns are reusable solutions to common programming problems. They were popularized with the 1994 book Design Patterns: Elements of Reusable Object-Oriented Software by Erich Gamma, John Vlissides, Ralph Johnson and Richard Helm (who are commonly known as a Gang of Four, hence the GoF acronym).
The original book was written using C++ and Smalltalk as examples, but since then, design patterns have been adapted to every programming language imaginable: C#, Java, PHP and even programming languages that aren't strictly object-oriented, such as JavaScript.
The appeal of design patterns is immortal: we see them in libraries, some of them are intrinsic in programming languages, and you probably use them on a daily basis even if you don't realize they are there.
What Patterns Does This Course Cover?
This course covers all the GoF design patterns. In fact, here's the full list of what is covered:
SOLID Design Principles: Single Responsibility Principle, Open-Closed Principle, Liskov Substitution Principle, Interface Segregation Principle and Dependency Inversion Principle
Creational Design Patterns: Builder, Factories (Factory Method and Abstract Factory), Prototype and Singleton
Structrural Design Patterns: Adapter, Bridge, Composite, Decorator, Façade, Flyweight and Proxy
Behavioral Design Patterns: Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Null Object, Observer, State, Strategy, Template Method and Visitor
Who Is the Course For?
This course is for Java developers who want to see not just textbook examples of design patterns, but also the different variations and tricks that can be applied to implement design patterns in a modern way. For example, the use of recursive generics helps us build fluent interfaces even when inheritance is involved.
Presentation Style
This course is presented as a (very large) series of live demonstrations being done in IntelliJ IDEA and presented using the Kinetica rendering engine. Kinetica removes the visual clutter of the IDE, making you focus on code, which is rendered perfectly, whether you are watching the course on a big screen or a mobile phone.
Most demos are single-file, so you can download the file attached to the lesson and run it in IntelliJ, Eclipse or another IDE of your choice.
This course does not use UML class diagrams; all of demos are live coding. I use IntelliJ and various Maven packages where necessary.
Instructor Details
- 4.5 Rating
9,758 Reviews
Dmitri Nesteruk
Dmitri is a quant, developer, book author and course author. His interests lie in software development and integration practices in the areas of computation, quantitative finance and algorithmic trading. His technological interests include C# and C++ programming as well high-performance computing using technologies such as CUDA and FPGAs. He has been a C# MVP since 2009.
More courses by Dmitri Nesteruk
Learn Parallel Programming with C# and .NET (2019)
4.6 (4,564 Reviews)
Provider: Udemy
Time: 5.3h
$14.99
Reviews
By Jennya Dobreva on 6/10/2026
This course helped me to understand better the design patterns and to enrich my knowledge with the names and the approaches I use in my coding. It would be better to have some UML drawings, just to understand schema for the dependencies which would help for consistent understanding of the changes and going back and forth during the presentation. Otherwise, I would say that the course is great and very good English and pronunciation. Спасибо Дмитри! Всего хорошего!
By Dimitrios Vourdoukas on 11/27/2025
I would find the material even more effective if the explanations progressed in two ways: first, from high-level conceptual representations, as you already did, and in a visual format such as diagrams, toward concrete implementations; and second, from low to higher levels of complexity, starting with simple, real life examples and gradually moving to more advanced ones. I really appreciate the coding exercises and the effort put into the course.
By Michael Goshey on 4/3/2025
Great course! Dmitri is brilliant and obviously very well-versed in the material. My only slight dislike was the coverage of the Adapter pattern, as it felt like too much time and effort was spent propping up the implementation of the example (rendering lines in vector objects from points) and its hashCode() and toSpring() implementations, to the point where the pattern became a bit of an afterthought. That notwithstanding, I'd happily take another course from Dmitri.
By Jennifer Fong on 10/1/2022
I thought the instruction was excellent: crisp, concise and clearly knowledgeable. The lectures had a smooth flow which exemplified strong command of the subject matter. The examples focused on clearly presenting the concepts rather than getting bogged down in real-world complexity. At the same time, the applications were varied in context. A few of the coding exercises were perhaps more complex than needed, but overall, they related to the subject material. I really appreciated the nuances of some of the alternative approaches. I enjoyed the content and would recommend it to friends.
By Philipp Baltzer on 11/11/2021
Wrote my last JavaCode 3 years ago when i was studying. Thought i'd have a hard time recapping all of that in a 10h course, but everything is explained very well and detailled. The instructor repeats important patterns while teaching new ones, so it's pretty hard to not take everything into account learned from the lessons before. Exercises will firm the knowledge acquired. Awesome!
By Igor Houwat on 1/17/2021
This is an amazing course. The instructor is very knowledgeable about design patterns. What comes across in particular is his clarity of thought in both his coding and ability to express ideas; quite IMPRESSIVE really. The course content is very condensed. The instructor doesn't mince his words and goes straight to the point, which means that you feel you get much more than the 10.5 hours advertised! Some of the reviewers complain about the rapid speed of the instructor's delivery, but I don't mind that at all. He keeps things going at a good pace, and you can always rewind if needed. Another plus is that you get more than 'design patterns' out of the course. There are a lot of 'unspoken' lessons that I have learned by rereading through his code and solutions to the exercises. His use of 'modern' Java features was very welcome to the learning experience, given I am new to the language. I really struggled taking off half a star, but the reasons I did that is that the instructor set the bar so high with his delivery and approach. The two niggles I had were: a) once in a while, he pastes some extra code in a lesson. Most of the times, that extra is minimal, but once in a while, the addition is a large chunk that remains unexplained, which distracts from grasping the pattern being taught; b) sometimes, the exercise directions are not clear (the test files help with hints). In summary: highly recommended.
By Gilberto Cezar De Almeida on 11/27/2020
Dmitri really masters design patterns and maybe this turn him so confident to speak so quickly explaining the concepts. It's so hard for the beginner to stick up with him without getting lost along the way. Maybe it's not his fault, maybe design patterns is confusing for the beginners. Also I think it might help to have more illustrations with real examples to support the introduction of each pattern. I recommend to visit Refactoring dot Guru Website to get some ideas.
By Marc-steeven Eyeni-Kantsey on 11/14/2020
Learning new things. Teaching with examples rather than just slides makes it much easier to understand as well.
By Selvakumar on 11/7/2020
Examples are very complex to understand.
By Emil Andrag on 10/20/2020
I love the presentation, but I type very slow.
By Sunil Sharma on 10/20/2020
This is indeed a very good design pattern course as it explains GoF's idea of Design Patterns nicely.
By Karan Bhange on 10/16/2020
I like the way everything is summarised in each section. Very useful for quick revision.









