Object-Oriented Design Patterns in Java by sdfsb346f


More Info

Object-Oriented Design Patterns in Java

This 3-day expert training course enables Java developers to learn how to apply the design
patterns used in advanced object-oriented practice to write loosely-coupled and highly
maintainable Java code.
Design Patterns have been conceived from many years of experience in the Object-Oriented
community and some patterns were popularised in the 1995 book of that name by the authors now
known as the “Gang of Four”.
Poorly maintained applications lead to problems such as code duplication and code which
developers are afraid to change for fear of causing errors. By promoting Design Patterns and best
practice, we can significantly reduce the number and the cost of bugs that appear in an application.
In this course, delegates will learn how to spot the “bad smells” in code which can cause
maintenance issues in the future and rectify them with the use of expert patterns.
We present a series of architectural approaches that can lead to higher quality development, such
as the use of interfaces rather than implementation and how to achieve better encapsulation and
loose coupling through refactoring of code.
Then, for each design pattern, we demonstrate how to refactor a poorly written code example
using principles of good Object-Oriented design, namely: good encapsulation, loose coupling, code
reuse and the open-closed principle, which states that classes should be made open for extension
and closed for modification. We thus present how to turn fragile code that causes maintenance
issues into robust, highly-maintainable code. Delegates are then asked to repeat the exercise with
a related problem.
We also discuss the importance of good Java package design, to avoid cyclic dependencies and to
enforce a good layered architecture, and how good testing practices can assist with refactoring.

This course will enable delegates with Java experience to understand and apply design patterns in
order to write code that is more testable, more reusable and more maintainable.
Delegates will understand the following patterns in detail: Singleton, Static Factory, Builder,
Command, Observer, Strategy, Adapter, Composite, State, Decorator, Iterator and Proxy and
Dependency Injection.

Topics Covered in Depth Include:
   ●   Principles of the Object-Oriented Approach    ● Package Dependencies
        ● Encapsulation                                 ● Minimise Dependencies between
        ● final classes and methods                        Packages
        ● Private Constructors                          ● Avoid Cyclic Dependencies
        ● Use of Accessors                              ● Layering your Architecture
        ● A Class should have a Single                  ● Tools to Promote and Enforce Proper
            Responsibility                                 Package Architecture
        ● Bind to Interfaces rather than                ● The Principles behind OSGi
            Implementation                              ● Typical Architectures in Enterprise
        ● Composition rather than Inheritance              Applications
        ● Loose Coupling                             ● Refactoring to Patterns

       ●   The Importance of good Unit Testing           ● Command
       ●   How to Unit Test Code                         ● Iterator
       ●   Code Coverage                                 ● Observer
       ●   Refactoring Tools                             ● State
   ● Introduction to Patterns                            ● Strategy
       ● The “Gang of Four”                         ● Structural Patterns
       ● Why do we need Patterns?                        ● Adapter
       ● Avoid Pattern Overuse                           ● Decorator
       ● Anti-Patterns                                   ● Composite
   ● Creational Patterns                                 ● Proxy
       ● Static Factory                             ● Architectural Patterns
       ● Builder                                         ● Dependency Injection
       ● Singleton                                       ● Model-View-Controller
   ● Behavioural Patterns
This course is aimed at developers and architects with at least twelve months of working with Java.
Also managers, analysts and developers of other strongly-typed object-oriented languages such as
C++ may benefit.
Please contact us at training@codeclass.co.uk or phone us on 020 7100 4254 if you are
interested in delivery of this course on your site and to discuss our extremely competitive rates.

To top