Java Design Patterns

  1. Structural Patterns
    1. Overview of Structural Patterns
      1. Focus on Class and Object Composition
        1. Goals of Flexibility and Efficiency
          1. Common Characteristics
            1. Comparison Framework
            2. Adapter Pattern
              1. Intent and Applicability
                1. Problem Context
                  1. Solution Structure
                    1. Target Interface
                      1. Adaptee Class
                        1. Adapter Class
                        2. Implementation Variations
                          1. Object Adapter
                            1. Class Adapter
                              1. Two-way Adapter
                              2. Common Use Cases
                                1. Legacy Code Integration
                                  1. Third-party Library Integration
                                    1. Interface Incompatibility Resolution
                                      1. API Wrapper Creation
                                      2. Consequences and Trade-offs
                                        1. Client-Adaptee Decoupling
                                          1. Increased System Complexity
                                            1. Performance Overhead
                                              1. Maintenance Considerations
                                              2. Best Practices and Guidelines
                                              3. Decorator Pattern
                                                1. Intent and Applicability
                                                  1. Problem Context
                                                    1. Solution Structure
                                                      1. Component Interface
                                                        1. ConcreteComponent Class
                                                          1. Decorator Abstract Class
                                                            1. ConcreteDecorator Classes
                                                            2. Implementation in Java
                                                              1. Composition-based Design
                                                                1. Java I/O Streams Example
                                                                  1. Decorator Chaining
                                                                  2. Common Use Cases
                                                                    1. Dynamic Responsibility Addition
                                                                      1. Subclass Explosion Avoidance
                                                                        1. Feature Enhancement
                                                                          1. Cross-cutting Concerns
                                                                          2. Consequences and Trade-offs
                                                                            1. Greater Flexibility than Inheritance
                                                                              1. Small Object Proliferation
                                                                                1. Complexity in Object Identity
                                                                                  1. Performance Considerations
                                                                                  2. Design Guidelines
                                                                                  3. Facade Pattern
                                                                                    1. Intent and Applicability
                                                                                      1. Problem Context
                                                                                        1. Solution Structure
                                                                                          1. Facade Class
                                                                                            1. Subsystem Classes
                                                                                            2. Implementation in Java
                                                                                              1. Subsystem Delegation
                                                                                                1. Interface Simplification
                                                                                                  1. Error Handling Strategies
                                                                                                  2. Common Use Cases
                                                                                                    1. Complex Subsystem Simplification
                                                                                                      1. Client-Subsystem Decoupling
                                                                                                        1. Layered Architecture Implementation
                                                                                                          1. API Simplification
                                                                                                          2. Consequences and Trade-offs
                                                                                                            1. Weak Coupling Promotion
                                                                                                              1. God Object Risk
                                                                                                                1. Limited Subsystem Access
                                                                                                                  1. Maintenance Benefits
                                                                                                                  2. Design Considerations
                                                                                                                  3. Composite Pattern
                                                                                                                    1. Intent and Applicability
                                                                                                                      1. Problem Context
                                                                                                                        1. Solution Structure
                                                                                                                          1. Component Interface
                                                                                                                            1. Leaf Class
                                                                                                                              1. Composite Class
                                                                                                                              2. Implementation in Java
                                                                                                                                1. Uniform Object Treatment
                                                                                                                                  1. Tree Structure Management
                                                                                                                                    1. Operation Propagation
                                                                                                                                    2. Common Use Cases
                                                                                                                                      1. Part-Whole Hierarchies
                                                                                                                                        1. Tree Structure Representation
                                                                                                                                          1. GUI Component Systems
                                                                                                                                            1. File System Modeling
                                                                                                                                            2. Consequences and Trade-offs
                                                                                                                                              1. Simplified Client Code
                                                                                                                                                1. Component Type Restriction Difficulty
                                                                                                                                                  1. Performance Implications
                                                                                                                                                    1. Memory Usage Considerations
                                                                                                                                                    2. Implementation Strategies
                                                                                                                                                    3. Proxy Pattern
                                                                                                                                                      1. Intent and Applicability
                                                                                                                                                        1. Problem Context
                                                                                                                                                          1. Solution Structure
                                                                                                                                                            1. Subject Interface
                                                                                                                                                              1. RealSubject Class
                                                                                                                                                                1. Proxy Class
                                                                                                                                                                2. Types of Proxies
                                                                                                                                                                  1. Remote Proxy
                                                                                                                                                                    1. Virtual Proxy
                                                                                                                                                                      1. Protection Proxy
                                                                                                                                                                        1. Smart Proxy
                                                                                                                                                                          1. Cache Proxy
                                                                                                                                                                          2. Implementation in Java
                                                                                                                                                                            1. Static Proxy Implementation
                                                                                                                                                                              1. Dynamic Proxy Usage
                                                                                                                                                                                1. Reflection-based Proxies
                                                                                                                                                                                2. Common Use Cases
                                                                                                                                                                                  1. Access Control Implementation
                                                                                                                                                                                    1. Lazy Initialization
                                                                                                                                                                                      1. Logging and Monitoring
                                                                                                                                                                                        1. Caching Mechanisms
                                                                                                                                                                                          1. Remote Object Access
                                                                                                                                                                                          2. Consequences and Trade-offs
                                                                                                                                                                                            1. Additional Indirection Layer
                                                                                                                                                                                              1. Performance Overhead
                                                                                                                                                                                                1. Transparency Benefits
                                                                                                                                                                                                  1. Security Enhancement
                                                                                                                                                                                                  2. Advanced Proxy Techniques
                                                                                                                                                                                                  3. Bridge Pattern
                                                                                                                                                                                                    1. Intent and Applicability
                                                                                                                                                                                                      1. Problem Context
                                                                                                                                                                                                        1. Solution Structure
                                                                                                                                                                                                          1. Abstraction Class
                                                                                                                                                                                                            1. RefinedAbstraction
                                                                                                                                                                                                              1. Implementor Interface
                                                                                                                                                                                                                1. ConcreteImplementor Classes
                                                                                                                                                                                                                2. Implementation in Java
                                                                                                                                                                                                                  1. Abstraction-Implementation Composition
                                                                                                                                                                                                                    1. Interface Delegation
                                                                                                                                                                                                                      1. Hierarchy Separation
                                                                                                                                                                                                                      2. Common Use Cases
                                                                                                                                                                                                                        1. Interface-Implementation Decoupling
                                                                                                                                                                                                                          1. Platform Independence
                                                                                                                                                                                                                            1. Multiple Implementation Support
                                                                                                                                                                                                                              1. Runtime Implementation Switching
                                                                                                                                                                                                                              2. Consequences and Trade-offs
                                                                                                                                                                                                                                1. Improved Extensibility
                                                                                                                                                                                                                                  1. Increased Complexity
                                                                                                                                                                                                                                    1. Performance Considerations
                                                                                                                                                                                                                                      1. Design Flexibility
                                                                                                                                                                                                                                      2. Design Guidelines
                                                                                                                                                                                                                                      3. Flyweight Pattern
                                                                                                                                                                                                                                        1. Intent and Applicability
                                                                                                                                                                                                                                          1. Problem Context
                                                                                                                                                                                                                                            1. Solution Structure
                                                                                                                                                                                                                                              1. Flyweight Interface
                                                                                                                                                                                                                                                1. ConcreteFlyweight Class
                                                                                                                                                                                                                                                  1. UnsharedConcreteFlyweight Class
                                                                                                                                                                                                                                                    1. FlyweightFactory Class
                                                                                                                                                                                                                                                    2. State Management
                                                                                                                                                                                                                                                      1. Intrinsic State Characteristics
                                                                                                                                                                                                                                                        1. Extrinsic State Handling
                                                                                                                                                                                                                                                          1. State Separation Strategies
                                                                                                                                                                                                                                                          2. Implementation in Java
                                                                                                                                                                                                                                                            1. Object Pooling Techniques
                                                                                                                                                                                                                                                              1. Shared Object Caching
                                                                                                                                                                                                                                                                1. Factory Management
                                                                                                                                                                                                                                                                2. Common Use Cases
                                                                                                                                                                                                                                                                  1. Large Object Collections
                                                                                                                                                                                                                                                                    1. Memory Optimization
                                                                                                                                                                                                                                                                      1. Character Rendering Systems
                                                                                                                                                                                                                                                                        1. Game Object Management
                                                                                                                                                                                                                                                                        2. Consequences and Trade-offs
                                                                                                                                                                                                                                                                          1. Reduced Memory Usage
                                                                                                                                                                                                                                                                            1. State Management Complexity
                                                                                                                                                                                                                                                                              1. Performance Trade-offs
                                                                                                                                                                                                                                                                                1. Thread Safety Considerations
                                                                                                                                                                                                                                                                                2. Implementation Best Practices

                                                                                                                                                                                                                                                                              Previous

                                                                                                                                                                                                                                                                              2. Creational Patterns

                                                                                                                                                                                                                                                                              Go to top

                                                                                                                                                                                                                                                                              Next

                                                                                                                                                                                                                                                                              4. Behavioral Patterns