This module focuses on structural OO patterns - patterns that help with object composition or making complex designs more efficient and flexible. Included here are discussions of Decorator, Facade, Adapter, Proxy, Composite, Flyweight, and Bridge. Supporting OO principles will also be discussed, as well as design topics such as multiple inheritance use guidelines and tradeoffs between the principles and implementation approaches. The project assignment (using Decorator for this module) will be the first design and development effort for an application that will be extended and refactored in each follow-on module.

We continue the examination and assessment of OO design patterns by looking at creational patterns here. Creational patterns provide alternative approaches for creating and instantiating objects, strengthening designs by separating the logic for object creation from object use. Supporting principles (e.g. Dependency Inversion), concepts (deep and shallow copies), and example applications will be provided. OO patterns reviewed here include Factory, Abstract Factory, Singleton, Object Pool, Prototype, and Builder. The project assignment (using Abstract Factory for this module) will be another step in extending and refactoring the class-long application design and development effort.

The final full module of OO design pattern reviews focuses on the behavioral OO patterns, the largest category of patterns that help provide structure for object interactions and responsibilities. The lectures look in detail at Command, State, and Template patterns, with a somewhat briefer review of Iterator, Mediator, Memento, Interpreter, Chain of Responsibility, and Visitor. Supporting principles, pattern structures, and examples of use and implementation are also reviewed. The project assignment continues the build of the class-long application design and development effort, adding the Command pattern to support additional functionality.

In this last class module, we take a look at building patterns from other patterns - creating compound patterns - by examining the most commonly encountered compound pattern, Model/View/Controller (MVC). We also look at a development approach called Thinking in Patterns that encourages pattern use in the analysis and design process. (Both MVC and Thinking in Patterns will be revisited in the final OOAD course.) The capstone project provided here is the last step in the class-long design and development effort, integrating State, Singleton, and Observer patterns for extending and finalizing the application functionality.