Java Best Practices and Design Patterns Training

Attend this Java Best Practises and Design Patterns training course and learn to solve real-world software development problems, and deliver responsive applications that are fast and reliable. Learn how to leverage Java best practises, avoid pitfalls and perform industry-standard software development techniques. Learn design patterns in Java to implement proven solutions to reoccurring problems, and apply idioms and patterns to improve your Java code.

• Knowledge at the level of:
  • Course 471 , Java Programming Introduction
• Three to six months of Java programming experience
• You should be able to:
  • Understand Java classes, the inheritance model, polymorphism, and encapsulation
  • Use fundamental standard edition Java APIs
  • Apply object-oriented analysis and design, including defining classes and creating objects

Java Best Practices and Design Patterns Training Delivery Methods

• After-course instructor coaching benefit
• Learning Tree end-of-course exam included
• After-course computing sandbox included

Java Best Practices and Design Patterns Training Course Benefits

• Employ best practises to build reliable and scalable Java applications
• Effectively apply test-driven development to enhance program maintainability
• Solve architectural problems with proven design patterns
• Employ advanced Java APIs for multi-threaded programming

Java Design Patterns Course Outline

Effective Programming in Java

• Clarifying the goals of best practises
• Identifying the key characteristics of high-quality software
• Organising classes, packages and subsystems into layers
• Designing to the principles of SOLID

Applying Test-Driven Development

Exploiting a testing framework

• Composing and maintaining JUnit tests
• Taking advantage of advanced JUnit features
• Testing in the presence of exceptions

Monitoring software health using logging libraries

• Configuring logging with log4j and SLF4J
• Minimising the impact of logging on performance

Creating matchers and mock objects

• Writing custom Hamcrest matchers
• Testing with fake objects and mocks

Leveraging Design Patterns

Employing common design patterns

• Observer
• Iterator
• Template method
• Strategy
• State
• Singleton
• Data Accessor Object
• Data Transfer Object
• Composite
• ServiceLocator
• Proxy
• Factory

Refactoring legacy code

• Identifying reasons to change software
• Clarifying the mechanics of change
• Writing tests for legacy classes and methods

Extending Applications with Java Meta Programming

Improving type safety with generics and enum types

• Creating generic classes and methods
• Navigating generic class hierarchies
• Implementing enum types for fixed sets of constants

Adding metadata by writing annotations

• Leveraging the built-in and custom annotations
• Annotating with meta-annotations

Modifying runtime behaviour with reflection

• Retrieving class and method data dynamically
• Flagging methods with naming conventions
• Adding information to code with annotations
• Assessing disadvantages of reflection

Tuning for Maximum Performance

Measuring and improving performance

• Assessing response time
• Conducting load and stress tests
• Specifying strategies for improving performance

Exploiting garbage collectors

• Exploring garbage collection metrics
• Choosing appropriate algorithms for garbage collection
• Avoiding the hazards of finalizers
• Preventing memory leaks with reference types

Taking full advantage of threads

• Writing reliable thread-safe code
• Avoiding race hazards and deadlocks
• Employing the Executors framework

Bulletproofing a threaded application

• Synchronising and sharing data between threads
• Managing the performance implications of synchronization

Exploring alternatives to synchronization

• Taking advantage of the volatile modifier
• Eliminating data sharing with ThreadLocal variables

Architecting for Separation of Concerns

Allocating responsibilities to components

• Translating method calls with the adaptor pattern
• Adding behaviour with a proxy

Centralising the creation of objects

• Employing factories to achieve loose coupling
• Implementing Inversion of Control (IoC)