Java Technologies

Effective Java Programming Using Design Patterns


2 days


Instructor Lead


This course is designed for developers, software and system architects and project managers involved with the development of Java™ applications.


Experience in the following areas is required: Some prior programming experience in a procedural or object-oriented language.


This is an advanced Java™ Programming training course that teaches Java developers how to use design patterns and the latest advanced Java language skills effectively. With the advent of Java 5 and Java 6, the language has seen profound improvements of which not all developers are aware. This course highlights those improvements, as well as delving into a range of topics that an experienced Java developer needs, such as design patterns, performance (JVM, Garbage collection,memory leak, profiling etc), concurrency and refactoring issues: skills that underpin best Java development project practice worldwide. Topics include:

  • Study of best Java development project practice worldwide
  • Effective use of advanced Java language constructs
  • Study and applications of over 20 Design Patterns
  • Performance, concurrency and refactoring


Applying OO Concepts with Java

  • Objects and Messages
  • Encapsulation, minimizing accessibility and mutability
  • Polymorphism
  • Subtyping and Subclassing
  • Composition versus Inheritance
  • Design patterns with Java - an overview
  • Structural patterns
    • The Composition pattern
    • The Adapter pattern
    • The Bridge pattern
    • The Decorator Pattern

Effective Java

  • Creating and destroying Objects
  • Creational Design Patterns
    • The Factory Method provides
    • The Abstract Factory Method
    • The Builder Pattern
    • The Prototype Pattern
    • The Singleton Pattern
  • Common Methods and why they are important
    • equals and hashCode
    • toString
    • cloning, deep and shallow copying
    • comparing object
  • Managing object behavior with patterns
    • Events and changes
    • The chain of responsibility
    • The Observer pattern
    • The Mediator defines
    • The Chain of Responsibility
    • The Command pattern
  • Managing Object State and Function
    • The Visitor pattern adds function to a class
    • The State pattern
  • Generics
    • Implementing typesafe heterogeneous containers
    • Generic types and methods
    • Lists versus arrays, foreach versus other loops
    • The Iterator pattern
  • Enums and Annotations
    • Annotations versus Naming patterns
    • Defining your own annotations
  • Exceptions
    • Exceptions for exceptional conditions
    • Programming errors
    • Recoverable conditions
    • Unnecessary usages
    • Standard versus Custom exceptions
    • Documenting Exceptions
    • Capturing failure information
    • Ignored exceptions
  • Concurrency
    • Accessing shared mutable data
    • Effective use of synchronization
    • Executors, tasks and threads
    • Lazy initialization and concurrency

Refactoring Java Code

    • The basics of refactoring: Detect, characterize, design, modify
    • When to refactor
    • Tools
    • Moving a class
    • Extracting methods
    • Extracting supertypes
    • Conditionals vs Polymorphism