www.codeclass.co.uk Object-Oriented Design Patterns in Java 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 ● 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 www.codeclass.co.uk ● 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 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 email@example.com 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.