Design Patterns in Java Made Simple

Using patterns to improve flexibility of the design
Design Patterns in Java Made Simple
File Size :
1.77 GB
Total length :
4h 51m



Zoran Horvat


Last update




Design Patterns in Java Made Simple

What you’ll learn

How to apply design patterns to help simplify application design
How to reduce design complexity by moving responsibilities into collaborating classes

Design Patterns in Java Made Simple


Fair understanding of the Java programming language
Working knowledge of software design
Any knowledge of design patterns is a plus


More than two decades since design patterns have appeared, many developers consider them the most important discovery in software development. Others still find them a bad idea. And both are right! How comes?In this course, you will learn how design patterns can be applied to make code better: flexible, short, readable. Flexibility is the key element in design patterns. You will learn how to decide when and which pattern to apply by formally analyzing the need to flex around specific axis. You will learn which pattern is adding which kind of flexibility, and what are the most common forms of implementation in practice. You will also learn common pitfalls and ways to overcome them when applying specific patterns.Through a series of demonstrations, you will learn one design pattern at a time. In each demonstration, we shall start from an existing implementation which faces difficulties to accommodate the next requirement proposed by the customer. That will invariantly trigger a series of designing attempts, some doomed to fail, others having prospect to succeed. But what will learn in this course, is that each successful design will exhibit one kind of flexibility, which will be of critical importance to support the troublesome request posed by the customer. It will come as no surprise to you to learn that each such special kind of flexibility will be one specific design pattern.


Section 1: Introduction

Lecture 1 Understanding the Role of Design Patterns

Lecture 2 How This Course Is Structured

Section 2: Adding Behavior to an Object with the Decorator Pattern

Lecture 3 Motivation for the Decorator Pattern

Lecture 4 The First Attempt to Decorate a Class

Lecture 5 The Downfall of the Subclassing Decorator

Lecture 6 Using Object Composition Instead of Inheritance

Lecture 7 Summary

Section 3: Adapting to a Different Interface with the Adapter Pattern

Lecture 8 Advancing from Decorator to Adapter Pattern

Lecture 9 Implementing a Transparent Adapter

Lecture 10 Towards a Heavyweight Adapter

Lecture 11 Limiting the Role of Adapters

Lecture 12 Summary

Section 4: Constructing Flexible Behavior with the Strategy Pattern

Lecture 13 Understanding the Need for Flexibility

Lecture 14 Implementing the Strategy Pattern

Lecture 15 Implementing Strategies via the Interface

Lecture 16 Augmenting the Strategy Interface

Lecture 17 Demonstrating the Power of Strategies

Lecture 18 Implementing Strategies with Strategies

Lecture 19 Summary

Section 5: Decoupling Classes with the Abstract Factory Pattern

Lecture 20 Understanding the Need for Abstract Factory Pattern

Lecture 21 Understanding the Limitations of the Abstract Factory

Lecture 22 Attempting to Overcome the Limitations

Lecture 23 Implementing Concrete Factories

Lecture 24 Completing the Concrete Factories

Lecture 25 Demonstrating the Concrete Factories

Lecture 26 Summary

Section 6: Constructing Objects on the Fly with the Factory Method Pattern

Lecture 27 From Abstract Factory to Factory Method

Lecture 28 Holding State Behind a Factory Method

Lecture 29 Fixing Parameters with Factory Method

Lecture 30 Confining Propagation of Change with Factory Methods

Lecture 31 Currying Factory Methods

Lecture 32 Summary

Section 7: Encapsulating Construction Rules with the Builder Pattern

Lecture 33 Understanding Limitations of Factories

Lecture 34 Replacing Factory with Builder

Lecture 35 Adding Validation to the Builder

Lecture 36 Handling Variation and Optional Components

Lecture 37 Building a Factory Method

Lecture 38 Summary

Section 8: Constructing Complex Objects with the Builder Pattern

Lecture 39 Building a Graph of Objects

Lecture 40 Understanding the Need for a Consistent Builder

Lecture 41 Designing a Consistent Builder

Lecture 42 Adding Alternatives to a Consistent Builders

Lecture 43 Designing a Fluent Builder

Lecture 44 Designing an Immutable Builder

Lecture 45 Shameless Immutability in Builders

Lecture 46 Summary

Section 9: Treating Collection as an Object with the Composite Pattern

Lecture 47 Understanding Multitudes of Objects

Lecture 48 Inventing the Composite Element

Lecture 49 Understanding Recursive Nature of Composites

Lecture 50 Combining Composite and Factory Methods

Lecture 51 Combining Composite and Abstract Factory

Lecture 52 Reversing Composites: Representing One Element as Many

Lecture 53 Summary

Hands-on programmers who are struggling to keep their source code clean and extensible,Programmers who wish to apply design patterns without causing more harm than good,All those who wish to improve their object-oriented programming and design skills

Course Information:

Udemy | English | 4h 51m | 1.77 GB
Created by: Zoran Horvat

You Can See More Courses in the Developer >> Greetings from

New Courses

Scroll to Top