Structural Patterns

Structural patterns are about shape. In Java, they help you decide how types should relate to each other when the pressure is not object creation or workflow sequencing, but interface mismatch, layering, composition, access control, or hierarchy management.

This chapter treats structural patterns as design tools, not museum pieces. Some of them map directly to everyday Java work:

• Adapter when you must integrate an incompatible API cleanly
• Bridge when abstraction and implementation are changing independently
• Composite when clients should treat single objects and trees uniformly
• Decorator when behavior should be layered without multiplying subclasses
• Facade, Proxy, and Flyweight when subsystem shape, access boundaries, or memory pressure become the main design problem

The important question is not whether a class diagram matches the Gang of Four illustration perfectly. The important question is whether the pattern clarifies the boundary the code actually has.

Read the chapter with three review questions in mind:

• What is the structural problem here?
• Does the pattern reduce coupling or just move it around?
• Would idiomatic Java tools such as interfaces, composition, records, or standard library wrappers already solve most of the problem?

When structural patterns are applied well, they make large Java systems easier to extend. When applied mechanically, they produce wrapper layers nobody wants to debug.

In this section

• Introduction to Structural Patterns in Java Design
  Understand what Java structural patterns solve, when they beat inheritance, and how to choose among wrappers, bridges, composites, decorators, facades, and proxies.
• Adapter Pattern
  Use the Adapter pattern in Java when clients already have the right contract and a dependency needs translation into it.
  • Implementing Adapter Pattern in Java
    Implement Java adapters by keeping the target interface narrow, preferring object adapters, and isolating translation logic at the dependency boundary.
  • Class Adapter vs. Object Adapter
    Compare class and object adapters in Java, with emphasis on why composition-based object adapters are usually the safer default.
  • Interface vs. Implementation Adapters
    Distinguish listener and callback adapters from dependency wrappers so Java adapter code stays purposeful instead of generic.
  • Adapter Pattern Use Cases and Examples in Java
    See where the Adapter pattern genuinely helps in Java systems, from legacy APIs and vendor SDKs to testing seams and incremental migrations.
• Bridge Pattern
  Use the Bridge pattern in Java when abstraction and implementation need to vary independently instead of multiplying subclasses.
  • Implementing Bridge in Java
    Implement the Bridge pattern in Java by separating the abstraction your clients use from the implementation family that actually does the work.
  • Decoupling Abstraction and Implementation
    Understand why the Bridge pattern separates client-facing abstractions from implementation details in Java and when that split is worth the complexity.
  • Bridge Pattern vs. Adapter Pattern
    Compare Bridge and Adapter in Java so interface translation and two-axis abstraction design do not get confused.
  • Bridge Pattern Use Cases and Examples in Java
    See where the Bridge pattern fits in Java systems, especially where abstraction and platform or transport concerns evolve separately.
• Composite Pattern
  Use the Composite pattern in Java when clients should work with single objects and recursive groups through one common contract.
  • Implementing Composite in Java
    Implement Composite in Java with a clear component contract, disciplined child ownership, and traversal rules that fit recursive structures.
  • Component, Leaf, and Composite Classes
    Design the three Composite roles in Java deliberately so the shared contract stays useful and child-management rules stay explicit.
  • Managing Hierarchical Structures with the Composite Pattern
    Manage Java composite hierarchies with explicit ownership, cycle rules, mutation boundaries, and aggregation semantics.
  • Iteration and Recursion in Composites
    Choose traversal style for Java composites deliberately, balancing recursion, explicit iterators, streams, and failure handling.
  • Composite Pattern Use Cases and Examples in Java
    See where Composite earns its place in Java systems, especially UI trees, file-like hierarchies, bundles, and recursive rule structures.
• Decorator Pattern
  Use the Decorator pattern in Java when behavior should be layered by wrapping instead of multiplying subclasses.
  • Implementing Decorator Pattern in Java
    Implement Java decorators by wrapping a small interface, delegating cleanly, and keeping each added behavior narrow and explicit.
  • Interface-Based Decorators
    Keep Java decorators practical by decorating narrow interfaces rather than large concrete types with sprawling method surfaces.
  • Chaining Decorators
    Chain Java decorators deliberately, because wrapper order changes behavior, visibility, performance, and failure semantics.
  • Decorator vs. Inheritance
    Compare Decorator with inheritance in Java and choose the one that matches variation shape, optional behavior, and runtime composition needs.
  • Decorator Pattern Use Cases and Examples in Java
    See where Decorator genuinely helps in Java, from I/O wrappers and handlers to logging, metrics, caching, and authorization layers.
• Facade Pattern
  Use the Facade pattern in Java to present a simpler subsystem boundary without pretending the subsystem itself has disappeared.
  • Implementing Facade in Java
    Implement Java facades by shaping a narrow task-oriented subsystem entry point instead of exposing every collaborating service directly.
  • Simplifying Complex Subsystems with the Facade Pattern
    Decide what a Java facade should simplify, what it should leave alone, and how much subsystem detail callers should still see.
  • Facade vs. Adapter Pattern
    Compare Facade and Adapter in Java so subsystem simplification and interface translation do not get confused.
  • Facade Pattern Use Cases and Examples in Java
    See where Facade is genuinely helpful in Java systems, from application services and legacy subsystems to document, media, and integration workflows.
• Flyweight Pattern
  Use the Flyweight pattern in Java when large numbers of similar objects make shared immutable state worth the extra discipline.
  • Implementing Flyweight in Java
    Implement Flyweight in Java by separating sharable immutable state from caller-supplied context and reusing flyweights through a factory.
  • Intrinsic vs. Extrinsic State in the Flyweight Pattern
    Separate shared immutable state from caller-supplied context so Java flyweights stay reusable, memory-efficient, and conceptually clean.
  • Managing Flyweight Factories
    Build Java flyweight factories around clear keys, safe caching rules, and lifecycle awareness so sharing remains correct instead of accidental.
  • Memory Optimization Techniques with the Flyweight Pattern
    Use Flyweight as a measured Java memory optimization, not as a theoretical pattern applied before allocation pressure is understood.
  • Flyweight Pattern Use Cases and Examples in Java
    See where Flyweight genuinely helps in Java systems, especially rendering, metadata reuse, catalogs, and other high-volume immutable state domains.
• Proxy Pattern
  Use the Proxy pattern in Java when access, laziness, remoteness, or policy must stand between the client and a real object.
  • Implementing Proxy in Java
    Implement Java proxies by preserving the original contract while controlling access, creation, or invocation of the real object.
  • Types of Proxies in Java
    Distinguish virtual, protection, and remote proxies in Java so the access concern is explicit instead of buried in a generic wrapper.
  • Dynamic Proxies in Java
    Use Java dynamic proxies when cross-cutting behavior should wrap many interface implementations without hand-writing one proxy class per type.
  • Proxy vs. Decorator Pattern
    Compare Proxy and Decorator in Java so access control and optional behavior layering are not treated as the same design move.
  • Proxy Pattern Use Cases and Examples in Java
    See where Proxy genuinely helps in Java systems, from remote clients and security wrappers to lazy loading and caching access boundaries.
• Private Class Data Pattern
  Use Private Class Data in Java when internal state must be grouped and protected from accidental exposure or inconsistent mutation.
  • Implementing Private Class Data in Java
    Implement Private Class Data in Java by hiding internal state holders and exposing only the operations needed to maintain invariants.
  • Benefits in Security and Encapsulation
    See how Private Class Data in Java helps preserve invariants, reduce accidental leakage, and narrow the public state surface.
  • Private Class Data Pattern Use Cases and Examples in Java
    See where Private Class Data helps in Java systems, especially around invariant-heavy entities, configuration holders, and sensitive internal state.
• Marker Interfaces and Annotations
  Compare marker interfaces and annotations in Java so metadata and framework signaling stay explicit and modern.
  • Implementing Marker Interfaces
    Understand when marker interfaces still make sense in Java and why annotations now cover many metadata uses more cleanly.
  • Using Annotations for Metadata
    Use Java annotations when metadata should be explicit, structured, and available to tools, frameworks, or runtime processing.
  • Processing Annotations at Runtime
    Process Java annotations at runtime carefully so reflection-based metadata remains understandable, testable, and not overused.
  • Marker Interfaces and Annotations Use Cases and Examples in Java
    See where marker interfaces and annotations fit in Java systems, from type capabilities to framework metadata and runtime policies.
• Extension Object Pattern
  Use the Extension Object pattern in Java when objects need optional capabilities without forcing every capability into the main type hierarchy.
  • Implementing Extension Object in Java
    Implement Extension Object in Java by exposing optional capabilities through explicit extension lookup rather than bloating the primary type.
  • Adding Functionality at Runtime with the Extension Object Pattern
    Add runtime capabilities in Java carefully so extension objects stay explicit and do not turn into hidden service locator behavior.
  • Extension Objects vs. Decorators
    Compare Extension Object and Decorator in Java so optional capabilities and wrapper-based behavior layering are not confused.
  • Extension Object Pattern Use Cases and Examples in Java
    See where Extension Object fits in Java systems, especially plugin models, optional capabilities, and modular feature attachments.