Docstoc

Object-Oriented Design Patterns in Java Training Course

Document Sample
Object-Oriented Design Patterns in Java Training Course Powered By Docstoc
					www.ukjavatraining.com



Object-Oriented Design Patterns in Java Training
Course

Summary:
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.

Objectives:
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         ● Loose Coupling
        ● Encapsulation                              ●   Package Dependencies
        ● final classes and methods                       ● Minimise Dependencies between
        ● Private Constructors                               Packages
        ● Use of Accessors                                ● Avoid Cyclic Dependencies
        ● A Class should have a Single                    ● Layering your Architecture
            Responsibility                                ● Tools to Promote and Enforce Proper
        ● Bind to Interfaces rather than                     Package Architecture
            Implementation                                ● The Principles behind OSGi
        ● Composition rather than Inheritance             ● Typical Architectures in Enterprise
www.ukjavatraining.com


           Applications                             ● Behavioural Patterns
   ●  Refactoring to Patterns                            ● Command
       ● The Importance of good Unit Testing             ● Iterator
       ● How to Unit Test Code                           ● Observer
       ● Code Coverage                                   ● State
       ● Refactoring Tools                               ● Strategy
   ● Introduction to Patterns                       ● Structural Patterns
       ● The “Gang of Four”                              ● Adapter
       ● Why do we need Patterns?                        ● Decorator
       ● Avoid Pattern Overuse                           ● Composite
       ● Anti-Patterns                                   ● Proxy
   ● Creational Patterns                            ● Architectural Patterns
       ● Static Factory                                  ● Dependency Injection
       ● Builder                                         ● Model-View-Controller
       ● Singleton
Pre-Requisites:
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.
Contact:
Please contact us at training@codeclass.co.uk or phone us on 0121 314 4347 if you are
interested in delivery of this course on your site and to discuss our extremely competitive rates.

				
DOCUMENT INFO