Java Design Patterns

  1. Creational Patterns
    1. Overview of Creational Patterns
      1. Focus on Object Creation Mechanisms
        1. Goals of Flexibility and Reuse
          1. Common Characteristics
            1. Comparison Framework
            2. Singleton Pattern
              1. Intent and Applicability
                1. Problem Context
                  1. Solution Structure
                    1. Private Constructor
                      1. Private Static Instance Variable
                        1. Public Static Accessor Method
                        2. Implementation Variations in Java
                          1. Eager Initialization
                            1. Static Block Initialization
                              1. Lazy Initialization
                                1. Thread-Safe Singleton
                                  1. Double-Checked Locking
                                    1. Bill Pugh Singleton Implementation
                                      1. Enum Singleton
                                      2. Common Use Cases
                                        1. Logging Systems
                                          1. Caching Mechanisms
                                            1. Thread Pool Management
                                              1. Configuration Settings
                                                1. Database Connection Pools
                                                2. Consequences and Trade-offs
                                                  1. Global State Management
                                                    1. Single Responsibility Principle Concerns
                                                      1. Unit Testing Challenges
                                                        1. Serialization Issues
                                                          1. Cloning Complications
                                                          2. Best Practices and Guidelines
                                                          3. Factory Method Pattern
                                                            1. Intent and Applicability
                                                              1. Problem Context
                                                                1. Solution Structure
                                                                  1. Product Interface
                                                                    1. ConcreteProduct Classes
                                                                      1. Creator Abstract Class
                                                                        1. ConcreteCreator Classes
                                                                        2. Implementation in Java
                                                                          1. Abstract Factory Methods
                                                                            1. Inheritance and Polymorphism Usage
                                                                              1. Return Type Considerations
                                                                              2. Common Use Cases
                                                                                1. Framework Development
                                                                                  1. Plugin Architectures
                                                                                    1. Library Design
                                                                                      1. Object Creation Abstraction
                                                                                      2. Consequences and Trade-offs
                                                                                        1. Decoupling Object Creation from Usage
                                                                                          1. Parallel Class Hierarchies
                                                                                            1. Increased Number of Classes
                                                                                              1. Enhanced Flexibility
                                                                                              2. Variations and Extensions
                                                                                              3. Abstract Factory Pattern
                                                                                                1. Intent and Applicability
                                                                                                  1. Problem Context
                                                                                                    1. Solution Structure
                                                                                                      1. AbstractFactory Interface
                                                                                                        1. ConcreteFactory Classes
                                                                                                          1. AbstractProduct Interfaces
                                                                                                            1. ConcreteProduct Classes
                                                                                                            2. Implementation in Java
                                                                                                              1. Interface-based Factory Design
                                                                                                                1. Product Family Composition
                                                                                                                  1. Factory Selection Mechanisms
                                                                                                                  2. Common Use Cases
                                                                                                                    1. UI Toolkit Themes
                                                                                                                      1. Cross-platform Applications
                                                                                                                        1. Database Driver Selection
                                                                                                                          1. Operating System Abstraction
                                                                                                                          2. Consequences and Trade-offs
                                                                                                                            1. Isolation of Concrete Classes
                                                                                                                              1. Easy Product Family Exchange
                                                                                                                                1. Difficulty Adding New Product Types
                                                                                                                                  1. Increased Abstraction Levels
                                                                                                                                  2. Relationship to Factory Method
                                                                                                                                  3. Builder Pattern
                                                                                                                                    1. Intent and Applicability
                                                                                                                                      1. Problem Context
                                                                                                                                        1. Solution Structure
                                                                                                                                          1. Builder Interface
                                                                                                                                            1. ConcreteBuilder Classes
                                                                                                                                              1. Director Class
                                                                                                                                                1. Product Class
                                                                                                                                                2. Implementation in Java
                                                                                                                                                  1. Static Nested Builder Class
                                                                                                                                                    1. Fluent Interface Design
                                                                                                                                                      1. Method Chaining
                                                                                                                                                        1. Validation Strategies
                                                                                                                                                        2. Common Use Cases
                                                                                                                                                          1. Complex Object Construction
                                                                                                                                                            1. Immutable Object Creation
                                                                                                                                                              1. Telescoping Constructor Problem
                                                                                                                                                                1. Configuration Object Building
                                                                                                                                                                2. Consequences and Trade-offs
                                                                                                                                                                  1. Separation of Construction and Representation
                                                                                                                                                                    1. Fine-grained Construction Control
                                                                                                                                                                      1. Increased Class Count
                                                                                                                                                                        1. Memory Overhead Considerations
                                                                                                                                                                        2. Modern Java Enhancements
                                                                                                                                                                        3. Prototype Pattern
                                                                                                                                                                          1. Intent and Applicability
                                                                                                                                                                            1. Problem Context
                                                                                                                                                                              1. Solution Structure
                                                                                                                                                                                1. Prototype Interface
                                                                                                                                                                                  1. ConcretePrototype Classes
                                                                                                                                                                                    1. Client Implementation
                                                                                                                                                                                    2. Implementation in Java
                                                                                                                                                                                      1. Cloneable Interface
                                                                                                                                                                                        1. Clone Method Override
                                                                                                                                                                                          1. Shallow Copy Implementation
                                                                                                                                                                                            1. Deep Copy Implementation
                                                                                                                                                                                              1. Copy Constructor Alternative
                                                                                                                                                                                              2. Common Use Cases
                                                                                                                                                                                                1. Expensive Object Creation
                                                                                                                                                                                                  1. Dynamic Object Configuration
                                                                                                                                                                                                    1. Object State Preservation
                                                                                                                                                                                                      1. Performance Optimization
                                                                                                                                                                                                      2. Consequences and Trade-offs
                                                                                                                                                                                                        1. Hiding Concrete Product Classes
                                                                                                                                                                                                          1. Complex Object Graph Cloning
                                                                                                                                                                                                            1. Circular Reference Handling
                                                                                                                                                                                                              1. Performance Benefits
                                                                                                                                                                                                              2. Cloning Strategies and Best Practices

                                                                                                                                                                                                            Previous

                                                                                                                                                                                                            1. Introduction to Design Patterns

                                                                                                                                                                                                            Go to top

                                                                                                                                                                                                            Next

                                                                                                                                                                                                            3. Structural Patterns