JV250: Java Design Patterns (4 days)

Course Overview

Design patterns are recurring solutions to common software problems. The specific details of a software problem may vary from project to project but patterns capture the essence and basic structure of successful experiences in solving similar problems. Design patterns thus offer a technique for capturing design and architecture, presenting and communicating architectural knowledge at all levels of a system, allowing experience and insights to be understood and distilled. This course is an in-depth introduction to design patterns for Java SE and EE systems and is designed for intermediate Java programmers wanting to advanced their mastery of the Java language by adopting best-practice coding conventions and patterns.

Covered patterns include fundamental patterns, creational patterns, behavioural patterns, structural patterns, system patterns, concurrency patterns, inter-tier data transfer patterns, presentation-tier patterns, business-tier patterns, persistence-framework patterns and integration-tier patterns.

Business Benefits

Design patterns incorporate proven techniques which embody the wisdom and experience of master practitioners and provide the following business benefits:

  • Patterns can save programmers costly time by offering time-tested patterns rather than requiring developers to invent, test and debug their own designs from scratch.
  • Patterns can reduce maintenance costs because most are created to assist refactoring and support evolvability.
  • Finally, design patterns can increase team productivity because the team can communicate about their design options and choices using well-understood, high-level pattern terminology rather than explaining low-level coding details.


Software Developers, Designers, Technical Managers and Architects interested in a hands-on exploration of Java SE and EE Design Patterns.


Students should be experienced programmers with a strong Java background. A basic knowledge of distributed computing, (RMI and/or CORBA/Java, Java EE), and a working knowledge of Servlets, JSPs and EJBs.

Course Objectives

After completing this course, participants will be able to:

  • Understand the principles of using design patterns
  • Understand several commonly used design patterns and be able to recognize them in other people's code
  • Choose the right design patterns for their own projects
  • Write flexible, reusable code
  • Abstract object construction with creational patterns
  • Compose objects and classes into larger groupings with structural patterns
  • Architect flexible and maintainable Java EE applications

Course Content - Common Topics

  • Patterns concepts (If required - approx 1 hour)

Course Content - Introductory Java SE Patterns Topics

  • Fundamental Patterns
    • Interface: Encapsulate a system behaviour contract
    • Marker Interface: Fulfil a contract without requiring specialised behaviour
    • Delegation: Use a supporting object to implement behaviour
    • Iterator: Simplify handling the members of a collection
    • Immutable: Create objects that don't change
    • Singleton: Handle one-of-a-kind objects
    • Type-Safe Enumerations: Represent objects which have one value from a finite set (pre and post Java 5)
    • Monostate: Handle all-the-same objects
  • Creational Patterns
    • Factory Method: Apply object-oriented principles and concepts to object creation
    • Abstract Factory: Use a factory approach when dealing with families of related objects
  • Structural Patterns
    • Adapter: Make one class look like another
    • Composite: Simplify implementing tree-like collections by defining operations which work for single and tree collections
    • Decorator: Encapsulate implementing additional responsibilities related to a common interface
    • Façade: Hide the complexity of a system behind a simple interface
    • Proxy: Hide the complexity of accessing an object
  • Behavioural Patterns
    • Command: Encapsulate a request as an object
    • Observer: Support loose-coupling between a subject and an observer
    • State: Encapsulate and simplify implementation of systems with fundamentally state-based behaviour
    • Strategy: Encapsulate and simplify implementation of systems with fundamentally algorithm-based behaviour
    • Template: Encapsulate alternative system behaviours

Course Content - Advanced Java SE Patterns Topics

  • More Creational Patterns
    • Builder: Encapsulate creation as a sequence of steps
    • Prototype: Simplify object creation in complex scenarios
  • More Structural Patterns
    • Bridge: Support abstractions/contracts and implementations to be extended independently
    • Flyweight: Allow large numbers of similar objects to be represented by one object (and some state)
  • More Behavioural Patterns
    • Chain of Responsibility: Enlist a set of objects to handle a request
    • Interpreter: Handle processing of simple languages
    • Mediator: Centralise complex communication and control between related objects
    • Memento: Persist object state
    • Visitor: Hide the complexity of adding new operations to code which works on hierarchies of objects
  • Other Java SE Patterns
  • Test Patterns
  • Bug Patterns
  • Java SE Anti-Patterns

Course Content - Introductory Java EE Patterns Topics

  • Introduction to Enterprise Patterns including the Model-View-Controller Pattern
  • Presentation-Tier Patterns and Strategies
    • Page View Strategy
    • View Helper Pattern
    • Front Controller Pattern
    • Composite View Pattern
    • Service to Worker Pattern
    • Dispatcher View Pattern
    • Best Practices
  • Business-Tier Patterns
    • Business Delegate
    • Service Locator
    • Transfer Object
    • Business Object
    • Session Façade
  • Integration-Tier Patterns
    • Data Access Object
    • Service Activator

Course Content - Advanced Java EE Patterns Topics

  • More Presentation-Tier Patterns
    • Intercepting Filter Pattern
    • Caching Filter Pattern
    • Presentation Tier Resource Pooling
    • Content Object
  • More Business-Tier Patterns
    • Application Service
    • Composite Entity
    • Value Object Assembler
    • Value List Handler
  • More Integration-Tier Patterns
    • Domain Store
    • Web Service Broker
  • Other Java EE Patterns
  • Web Service Patterns
  • Java EE Anti-Patterns
  • Examples

* The design pattern course material is modular and may be tailored to meet your exacting requirements. These courses encapsulate suggested streams for learning about relevant design patterns. For in-house training you may select the specific patterns which interest you.