Description
Description
This course provides a deep dive into object-oriented design patterns—essential tools for developing high-quality, maintainable software systems that meet requirements and ship on time. Geared towards developers and architects, the course blends formal design principles with real-world application, giving you both the conceptual foundation and the practical skills needed to build robust, reusable systems.
Focusing primarily on the well-known Gang of Four (GoF) design patterns, the course explores the most important patterns across Creational, Structural, and Behavioral categories. You’ll also get exposure to additional patterns, including Dependency Injection (DI) and common Enterprise Architecture Patterns.
While course examples are presented in Java, coding is not required during the labs. Instead, labs are hands-on and conceptual, focused on design thinking and applying patterns in practice through structured design exercises and projects.
Note: Java experience is helpful, but the focus is on design—not language-specific syntax.
Training Objectives
- By the end of this course you will:
- Understand key object-oriented design pattern concepts and terminology
- Apply patterns to design flexible scalable and maintainable software
- Gain fluency with the most common GoF design patterns
- Know when and how to use Creational Structural and Behavioral patterns
- Understand key enterprise and architectural patterns
- Design systems that reduce code duplication and improve modularity
- Communicate effectively using the shared vocabulary of design patterns
Course Outline
- Skills Covered<br />
- Creational Patterns<
- Factory Method – In-depth<
- Abstract Factory – In-depth<
- Singleton – In-depth<
- Builder – Brief<
- Prototype – Brief<
- Structural Patterns<
- Composite – In-depth<
- Adapter – In-depth<
- Proxy – In-depth<
- Bridge – Brief<
- Facade – Brief<
- Decorator – Brief<
- Behavioral Patterns<
- Iterator – In-depth<
- Strategy – In-depth<
- Observer – In-depth<
- Command – Introductory<
- Chain of Responsibility – Introductory<
- State, Visitor, Interpreter, Mediator – Brief<
- Other Patterns<
- Dependency Inversion (DI)<
- Enterprise Patterns: MVC, DAO, Business Delegate, Value Object<
- Session 1: Introduction to Design Patterns<
- Overview of Object-Oriented Concepts & Interfaces<
- Introduction to the Iterator Pattern (with Lab)<
- History and Origins of Design Patterns<
- Session 2: A Formal Approach to Design Patterns<
- Introduction to UML for Pattern Representation<
- Overview of the Gang of Four Patterns<
- Navigating the GoF Patterns Catalog<
- Session 3: Creational Patterns<
- Factory Method Pattern (with Lab)<
- Abstract Factory Pattern<
- Singleton Pattern<
- Brief look at Builder and Prototype Patterns<
- Session 4: Behavioral Patterns<
- Strategy Pattern (with Lab)<
- Template Method Pattern<
- Command & Chain of Responsibility Patterns<
- Other Behavioral Patterns Overview<
- Session 5: Structural Patterns<
- Decorator Pattern<
- Composite Pattern<
- Proxy Pattern<
- Façade and Bridge Patterns<
- Session 6: Dependency Injection<
- Overview of Dependency Inversion Principle<
- Introduction to Dependency Injection<
- Working with DI Containers<
- Session 7: Enterprise Patterns<
- Overview of Architectural Patterns<
- Business Delegate<
- Value Object<
- DAO / Repository Pattern<
- Model-View-Controller (MVC)




