Java Best Practices and Design Patterns

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

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
• Minimizing the impact of logging on performance

Creating matchers and mock objects

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

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

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 behavior with reflection

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

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

• Synchronizing 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

Allocating responsibilities to components

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

Centralizing the creation of objects

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