Design Patterns in Java Made Simple

Course Curriculum

Chapter 1: Introduction

Lecture 1: Understanding the Role of Design Patterns

Lecture 2: How This Course Is Structured

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

Lecture 1: Motivation for the Decorator Pattern

Lecture 2: The First Attempt to Decorate a Class

Lecture 3: The Downfall of the Subclassing Decorator

Lecture 4: Using Object Composition Instead of Inheritance

Lecture 5: Summary

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

Lecture 1: Advancing from Decorator to Adapter Pattern

Lecture 2: Implementing a Transparent Adapter

Lecture 3: Towards a Heavyweight Adapter

Lecture 4: Limiting the Role of Adapters

Lecture 5: Summary

Chapter 4: Constructing Flexible Behavior with the Strategy Pattern

Lecture 1: Understanding the Need for Flexibility

Lecture 2: Implementing the Strategy Pattern

Lecture 3: Implementing Strategies via the Interface

Lecture 4: Augmenting the Strategy Interface

Lecture 5: Demonstrating the Power of Strategies

Lecture 6: Implementing Strategies with Strategies

Lecture 7: Summary

Chapter 5: Decoupling Classes with the Abstract Factory Pattern

Lecture 1: Understanding the Need for Abstract Factory Pattern

Lecture 2: Understanding the Limitations of the Abstract Factory

Lecture 3: Attempting to Overcome the Limitations

Lecture 4: Implementing Concrete Factories

Lecture 5: Completing the Concrete Factories

Lecture 6: Demonstrating the Concrete Factories

Lecture 7: Summary

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

Lecture 1: From Abstract Factory to Factory Method

Lecture 2: Holding State Behind a Factory Method

Lecture 3: Fixing Parameters with Factory Method

Lecture 4: Confining Propagation of Change with Factory Methods

Lecture 5: Currying Factory Methods

Lecture 6: Summary

Chapter 7: Encapsulating Construction Rules with the Builder Pattern

Lecture 1: Understanding Limitations of Factories

Lecture 2: Replacing Factory with Builder

Lecture 3: Adding Validation to the Builder

Lecture 4: Handling Variation and Optional Components

Lecture 5: Building a Factory Method

Lecture 6: Summary

Chapter 8: Constructing Complex Objects with the Builder Pattern

Lecture 1: Building a Graph of Objects

Lecture 2: Understanding the Need for a Consistent Builder

Lecture 3: Designing a Consistent Builder

Lecture 4: Adding Alternatives to a Consistent Builders

Lecture 5: Designing a Fluent Builder

Lecture 6: Designing an Immutable Builder

Lecture 7: Shameless Immutability in Builders

Lecture 8: Summary

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

Lecture 1: Understanding Multitudes of Objects

Lecture 2: Inventing the Composite Element

Lecture 3: Understanding Recursive Nature of Composites

Lecture 4: Combining Composite and Factory Methods

Lecture 5: Combining Composite and Abstract Factory

Lecture 6: Reversing Composites: Representing One Element as Many

Lecture 7: Summary