1. Introduction
    1. Welcome
    2. What you should know before watching this course
    3. Using the exercise files
  2. Design Patterns
    1. Understanding the need for design patterns
    2. What are design patterns
    3. Using design patterns
  3. The Strategy Pattern
    1. Understanding the pitfalls of inheritance and interfaces
    2. Encapsulating code that varies
    3. Programming to an interface
    4. Setting behavior dynamically
    5. Exploring the strategy pattern
    6. Understanding why HAS-A is better than IS-A
  4. The Observer Pattern
    1. Using the observer pattern in the real world
    2. Exploring the observer pattern
    3. Understanding the observer pattern
    4. Implementing the observer pattern
    5. Using Java's Observer and Observable classes
    6. Implementing the observer pattern with Java's Observer and Observable classes
    7. The advantages of loose coupling
  5. The Decorator Pattern
    1. Creating chaos with inheritance
    2. Understanding the open-closed principle
    3. Extending behavior with composition
    4. Understanding the decorator pattern
    5. Implementing the decorator pattern
    6. Understanding decorators in Java libraries
    7. Using java.io decorators
  6. The Singleton Pattern
    1. What is the singleton pattern
    2. Understanding the classic singleton pattern
    3. Implementing the classic singleton pattern
    4. Dealing with multithreading
    5. Improving the singleton pattern implementation
  7. The State Pattern
    1. What is a state machine
    2. Revisiting the design for a state machine
    3. Understanding the state pattern
    4. Implementing the state pattern
    5. Comparing the state and strategy patterns
  8. The Collection Pattern
    1. Encapsulating iteration
    2. Exploring the iterator pattern
    3. Implementing the iterator pattern
    4. Using Java's built-in iterators
    5. Implementing with Java's built-in iterators
    6. Making sure classes have only one responsibility
  9. Factories
    1. Encapsulating object creation
    2. Understanding the Simple Factory idiom
    3. Implementing the Simple Factory idiom
    4. Exploring the factory method pattern
    5. Implementing the factory method pattern
  10. Conclusion
    1. Looking at what we've done and where to go from here
    2. Additional resources