Behavioral Patterns

Behavioral patterns are about collaboration over time. They matter when the main design pressure is no longer object creation or structural wrapping, but how decisions are made, how behavior changes, and how messages move through a system.

In Java, this chapter is not just about memorizing classical names. It is about recognizing recurring runtime design pressures:

• choose one of several algorithms cleanly
• let behavior change when internal state changes
• coordinate many participants without every class knowing every other class
• propagate events without hard-wiring all observers directly
• express commands, rules, or workflows in a form the rest of the system can reason about

Some behavioral patterns remain close to their classic form. Others look different in modern Java because lambdas, streams, listeners, reactive APIs, dependency injection, and framework callbacks have changed how behavior is packaged.

The chapter is strongest if you read each pattern with three questions in mind:

• What runtime collaboration problem is this pattern solving?
• Is the pattern clarifying the flow of behavior, or only adding indirection?
• Would modern Java language or library features already solve most of the problem more directly?

In this section

• Introduction to Behavioral Patterns in Java
  Understand what Java behavioral patterns solve, how they differ from structural and creational concerns, and how to choose among runtime collaboration styles.
• Chain of Responsibility Pattern
  Use Chain of Responsibility in Java when a request should move through ordered handlers without hardwiring one receiver up front.
  • Implementing Chain of Responsibility in Java
    Build a Java handler chain that forwards, short-circuits, or enriches requests without turning the flow into hidden control logic.
  • Dynamic vs. Static Chain Construction in Java
    Compare fixed and runtime-built Java handler chains so you can choose between predictability, configurability, and operational complexity.
  • Avoiding Sender-Receiver Coupling with Chain of Responsibility
    Learn how Chain of Responsibility loosens sender-receiver dependencies in Java and what coupling still remains in handler ordering and shared context.
  • Chain of Responsibility Pattern Use Cases and Examples in Java
    See where Chain of Responsibility fits in Java logging, middleware, validation, and auth flows, and where a simpler dispatcher is better.
• Command Pattern
  Use the Command pattern in Java when requests should be captured as objects that can be queued, logged, retried, or undone.
  • Implementing Command in Java
    Implement Command in Java by separating request intent from invocation timing and receiver details.
  • Invoker, Command, and Receiver Roles
    Distinguish the Command roles in Java so request creation, request invocation, and actual work execution stay properly separated.
  • Implementing Undo and Redo with the Command Pattern
    Use Command for undo and redo in Java when reversible intent and command history are worth modeling explicitly.
  • Command Pattern in Multithreading
    Use Command in Java multithreaded systems when work items must cross thread boundaries cleanly, but keep thread safety and retry semantics explicit.
  • Command Pattern Use Cases and Examples in Java
    See where Command genuinely helps in Java systems, from UI actions and job queues to undo stacks, schedulers, and audit trails.
• Interpreter Pattern
  Use the Interpreter pattern in Java for small, stable languages where explicit grammar objects are easier to evolve than ad hoc parsing logic.
  • Implementing the Interpreter Pattern in Java
    Build a small Java interpreter from grammar objects to evaluation logic, and understand when the pattern is preferable to ad hoc parsing.
  • Advanced Interpreter Implementation Techniques in Java
    Use ASTs, parsers, caching, and validation techniques to keep Java interpreters maintainable once a toy grammar turns real.
  • Interpreter Pattern Performance Trade-Offs in Java
    Review parsing, allocation, caching, and hybrid-compiler trade-offs before using the Interpreter pattern in performance-sensitive Java code.
  • Interpreter Pattern Use Cases and Examples in Java
    See where Interpreter fits in Java expression evaluators, config rules, and DSLs, and where a parser generator or compiler is the better tool.
• Iterator Pattern
  Use the Iterator pattern in Java when traversal should stay separate from collection internals and clients need a stable way to walk data.
  • Implementing Iterator in Java
    Implement Java iterators when custom aggregates need explicit traversal without exposing their internal representation.
  • Internal vs. External Iterators
    Compare Java external iterators with callback- or stream-style internal iteration so traversal control stays intentional.
  • Fail-Fast and Fail-Safe Iterators
    Understand Java fail-fast and fail-safe iterator behavior so mutation and traversal expectations stay realistic.
  • Enhancing Iterators
    Extend Java iterators carefully when traversal needs filtering, peeking, or domain-specific movement without turning the cursor API into a grab bag.
  • Iterator Pattern Use Cases and Examples in Java
    See where Iterator genuinely helps in Java systems, especially for custom aggregates, trees, graphs, and domain-specific traversal order.
• Mediator Pattern
  Use the Mediator pattern in Java when too many components coordinate directly and the collaboration rules need one explicit home.
  • Implementing Mediator in Java
    Implement Mediator in Java by moving coordination rules into one explicit collaborator instead of spreading them across peer objects.
  • Reducing Tight Coupling with the Mediator Pattern
    Use Mediator in Java to reduce peer-to-peer awareness without hiding the collaboration rules that still need to be designed explicitly.
  • Mediator vs. Observer Pattern
    Compare Mediator and Observer in Java so centralized coordination and event notification are not treated as the same design move.
  • Mediator Pattern Use Cases and Examples in Java
    See where Mediator genuinely helps in Java systems, especially in UI coordination, workflow hubs, and multi-component interaction rules.
• Memento Pattern
  Use the Memento pattern in Java to capture restorable state without exposing internal representation, and know when snapshot cost becomes the real constraint.
  • Implementing Memento in Java
    Capture and restore Java object state without exposing internals, and decide how much snapshot responsibility belongs in each class.
  • Originator, Memento, and Caretaker Roles in Java
    Understand how Originator, Memento, and Caretaker divide responsibility so Java undo logic stays encapsulated and reviewable.
  • Handling State Restoration in Java with Memento Pattern
    Choose snapshot granularity, history retention, and restore semantics so Memento stays useful in Java without becoming a memory sink.
  • Serialization with the Memento Pattern in Java
    Learn when Java serialization can support memento-style snapshots and when custom state capture is safer and cheaper.
  • Memento Pattern Use Cases and Examples in Java
    See where Memento fits in undo stacks, editors, workflows, and transactional recovery, and where event logs or versioning are stronger choices.
• Observer Pattern with Modern Alternatives
  Use Observer-style designs in Java when change notifications should fan out, while also understanding when listeners, streams, or pub-sub models are better fits.
  • Implementing Observer Pattern in Java
    Implement Observer-style notification in Java by making subject responsibilities, listener contracts, and event semantics explicit.
  • Using Property Change Listeners
    Use Java property change listeners when object state changes need a conventional listener model without inventing a custom observer framework.
  • Event Handling in GUI Frameworks
    Understand how Java GUI event handling uses observer-style notification and where framework event models go beyond the classical Observer pattern.
  • Observer Pattern vs. Pub/Sub Models
    Compare in-process Observer with broader pub-sub models in Java so local listeners are not confused with brokered event systems.
  • Observer Pattern with Modern Alternatives Use Cases and Examples in Java
    See where Observer-style designs help in Java systems, from UI events and model listeners to domain events and local notification flows.
• State Pattern
  Use the State pattern in Java when behavior changes meaningfully with the object's current state and conditionals start obscuring the model.
  • Implementing State in Java
    Implement State in Java by moving state-specific behavior out of sprawling conditionals and into explicit state objects or state models.
  • Context and State Classes in the State Pattern
    Design Java State contexts and state types so responsibilities stay explicit and transitions remain understandable.
  • State vs. Strategy Pattern
    Compare State and Strategy in Java so caller-selected algorithms and lifecycle-driven behavior changes do not get confused.
  • State Pattern Use Cases and Examples in Java
    See where State genuinely helps in Java systems, especially around lifecycle-rich domains such as orders, workflows, connections, and UI modes.
• Strategy Pattern
  Use the Strategy pattern in Java when caller-selected behavior should vary cleanly without piling conditionals into one class.
  • Implementing Strategy in Java
    Implement Strategy in Java by separating the stable context from the interchangeable algorithm contract and making the choice explicit.
  • Functional Strategies with Lambdas
    Use lambdas for Java strategies when the behavior is small and the strategy contract is naturally functional.
  • Context and Strategy Interfaces in the Strategy Pattern
    Design Java Strategy contexts and contracts so the variable behavior is isolated without leaking too much context into the strategy.
  • Strategy Pattern Use Cases and Examples in Java
    See where Strategy genuinely helps in Java systems, from pricing and ranking to retry policies, serialization choices, and routing rules.
• Template Method Pattern
  Use Template Method in Java when an algorithm skeleton should remain fixed while selected steps vary across subclasses.
  • Implementing Template Method in Java
    Implement Template Method in Java by fixing algorithm structure in a base type and deferring selected steps to subclasses.
  • Hook Methods in the Template Method Pattern
    Use Template Method hooks in Java when subclasses need optional extension points without overriding the whole algorithm.
  • Fixed Algorithm Structure in the Template Method Pattern
    Keep the Java Template Method skeleton stable so subclasses vary steps without silently changing the overall algorithm contract.
  • Template Method Pattern Use Cases and Examples in Java
    See where Template Method genuinely helps in Java systems, especially in framework base classes, exporters, processors, and skeletal APIs.
• Visitor Pattern
  Use the Visitor pattern in Java when operations should vary more often than the object structure they operate on.
  • Implementing Visitor in Java
    Implement Visitor in Java when the object structure is stable and the system needs multiple separate operations over it.
  • Double Dispatch in the Visitor Pattern
    Understand Java Visitor double dispatch so the chosen visit method depends on both the element type and the visitor type.
  • Extensibility with Visitors
    Understand the real extensibility trade-off in Java Visitor: new operations are easy, new element types are expensive.
  • Visitor vs. Iterator Pattern
    Compare Visitor and Iterator in Java so traversal and operation-separation concerns are not treated as the same design move.
  • Visitor Pattern Use Cases and Examples in Java
    See where Visitor genuinely helps in Java systems, especially with ASTs, document trees, rule structures, and stable object models needing many operations.
• Null Object Pattern
  Use Null Object in Java when a default no-op collaborator makes absence explicit and safer than scattered null checks.
  • Implementing Null Object Pattern in Java
    Implement a Java null object that removes scattered null checks without hiding real error conditions or state transitions.
  • Simplifying Code Logic with the Null Object Pattern
    Use Null Object to simplify Java branching and collaboration code, and know when explicit Optional-style absence is clearer.
  • Null Object Pattern Use Cases and Examples in Java
    See where Null Object fits in logging, collection traversal, strategy defaults, and service fallbacks, and where it becomes a misleading silent failure.
• Specification Pattern
  Use the Specification pattern in Java to encode business rules as reusable predicates that can be composed, tested, and translated across boundaries.
  • Implementing the Specification Pattern in Java
    Implement reusable Java specifications as predicates or domain objects so business rules stay composable and testable.
  • Composing Specifications in Java
    Combine Java specifications with logical operators and functional helpers to express complex business rules without burying them in queries.
  • Specification Pattern Use Cases and Examples in Java
    See where Specification fits in filtering, validation, repository queries, and DDD-style policies, and where simpler predicates are enough.