Skip to content
UdemyJavaPaid courseIntermediate levelCertificate

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.

Best forWorking Java developers who want every GoF pattern shown in real code, with coding exercises along the way.
Skip it ifYou want diagrams, a gentle pace, or simple toy examples while meeting design patterns for the first time.

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.
Przemysław Bogdański, a student

Intermediate is right: it expects solid Java and OO basics, and a beginner in the reviews found it hard to follow.

icon
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

  1. 1Introduction 1 free preview1 lecture · 5 min
  2. 2SOLID Design Principles 1 free preview7 lectures · 1.1 hours
  3. 3Builder 1 free preview8 lectures · 1 quiz · 43 min
  4. 4Factories5 lectures · 1 quiz · 30 min
  5. 5Prototype5 lectures · 1 quiz · 21 min
  6. 6Singleton12 lectures · 1 quiz · 1 hour
  7. 7Adapter4 lectures · 1 quiz · 20 min
  8. 8Bridge3 lectures · 1 quiz · 11 min
  9. 9Composite4 lectures · 1 quiz · 20 min
  10. 10Decorator6 lectures · 1 quiz · 31 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

icon
Quality Score

Content Quality
/
Video Quality
/
Qualified Instructor
/
Course Pace
/
Course Depth & Coverage
/

Overall Score : 90 / 100

icon
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.

icon
Udemy Discount

The discount is applied through our link. Open the course from here and Udemy's current promotional price is applied at checkout on most courses, no code to type.

Some courses are excluded from Udemy's promotions. If the price does not drop, clear your browser cookies and use the button again.

icon
Instructor Details

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. 

icon
More courses by Dmitri Nesteruk

$124.99

$14.99

$14.99

$11.99

$14.99

$10.99

icon
Reviews

4.5

9,758 ratings on Udemy

Select a bar to show only those reviews.Select the bar again to show every rating.

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.

Showing 12 of 310 reviews