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.

Audience

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

Pre-requisites

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.