Modern GoF Patterns: Builder, Factory, and Visitor via Pattern Matching

01Deconstructing the Classic Visitor Pattern

For decades, the classic Gang of Four Visitor pattern was the standard object-oriented solution for adding operations to composite object structures without modifying the elements themselves. However, classic Visitor requires double dispatch: every visited node must implement an accept(Visitor v) method, and every visitor interface must declare explicit visit(ConcreteNodeA) and visit(ConcreteNodeB) overloads.

This architectural ceremony introduces immense friction. Adding a new subtype requires editing every visitor interface and implementation across the entire codebase. Furthermore, passing contextual state through the visit traversal requires mutable accumulator fields inside the visitor instance, introducing subtle concurrency vulnerabilities.

Modern Java completely replaces the Visitor pattern with the combination of sealed interfaces and pattern-matching switch expressions. Because the compiler knows every possible implementation of a sealed type at compile time, a switch expression over the sealed root is provably exhaustive—eliminating both double dispatch and default fallback branches.

02Immutable Records with Fluent Builders

The Builder pattern remains essential when constructing complex domain objects with numerous optional parameters, validation constraints, and nested configuration options. However, writing traditional mutable builders with repetitive private fields, setters, and build() methods produces hundreds of lines of boilerplate.

In Java 21, we combine records with static builder classes. The record provides immutable value semantics, canonical constructors with compact validation, and automatic equals, hashCode, and toString implementations. The builder provides a fluent, step-wise configuration interface that enforces invariant validation before instantiation.

By placing validation logic inside the record's compact constructor, we guarantee that no code path can ever create an invalid instance—even if an attacker attempts reflection or deserialization bypasses.

03Architectural Comparison: Classic vs Modern Patterns

Let us examine how modern Java idioms transform classic architectural patterns across maintainability, type safety, and runtime characteristics:

Notice how modern patterns shift failure modes from runtime ClassCastExceptions and missing visit methods to compile-time verification errors.

+--------------------+----------------------------+----------------------------------+| Classic GoF        | Legacy Java Approach       | Modern Java 21 Idiom             |+--------------------+----------------------------+----------------------------------+| Visitor            | Interface + accept()       | Sealed interface + switch record || Strategy           | Concrete classes / anon    | Lambdas / Method References      || Builder            | Mutable Java Beans         | Record + static fluent builder   || Factory Method     | Reflection / string keys   | Sealed interface factory methods || State Pattern      | Mutable state reference    | Sealed state machine transitions |+--------------------+----------------------------+----------------------------------+

04Exhaustive State Machines with Sealed Transitions

Modeling state transitions using sealed interfaces guarantees that invalid transitions are rejected at compile time. In a payment processing gateway, for instance, an OrderState can be represented as a sealed interface permitted only by OrderPending, OrderAuthorized, OrderCaptured, and OrderRefunded.

When handling state transitions, a pure transition function takes the current state and incoming event, returning the new state. If a developer later introduces a new OrderChargeback state, every transition switch in the codebase will immediately produce a compilation error until explicitly handled.

This technique eliminates the classic enterprise bug where an unhandled state falls through an arbitrary if-else chain and silently leaves accounts in corrupted intermediate conditions.