The Template Method pattern defines the skeleton of an algorithm in a base class and lets subclasses fill in the steps — without changing the overall structure. Complete Java guide: data migration pipeline with invariant skeleton, overridable hooks, and the Hollywood Principle. Includes comparison with Strategy and when to use each.
The Strategy pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable at runtime. No more switch statements for algorithm selection. Complete Java guide: sorting strategy with BubbleSort/MergeSort/QuickSort, runtime selection, Java 8 functional shortcut with Comparator, and when Strategy is overkill.
The State pattern lets an object change its behaviour when its internal state changes — as if the object changed its class. Eliminate sprawling if-else state machines. Complete Java guide: traffic light example, state-driven transitions, how State differs from Strategy, vending machine walkthrough, and when to use enums vs State objects.
The Observer pattern defines a one-to-many dependency: when one object changes state, all dependents are notified automatically. Complete Java guide: stock price alert system, dynamic subscribe/unsubscribe, push vs pull notification models, java.util.Observable pitfalls, PropertyChangeListener, reactive extensions, and thread-safety considerations.
The Memento pattern captures an object's internal state in a snapshot and restores it later — without violating encapsulation. Complete Java guide: text editor undo with multi-field state, the Originator/Memento/Caretaker triad, how to keep mementos opaque, serialization as Memento, and bounded undo history management.
The Mediator pattern replaces a web of N² direct object references with N connections through a central coordinator. Complete Java guide: chat room example, O(N²) vs O(N) dependency analysis, MVC as a Mediator, Spring's ApplicationEventPublisher, and how Mediator differs from Observer and Facade.
The Iterator pattern provides a uniform way to traverse a collection without exposing its internal structure. Complete Java guide: custom BookShelf iterator, filtered decade iterator, how Java's for-each loop works under the hood, Iterable vs Iterator, and when to write a custom iterator vs using Streams.
The Command pattern turns a request into a standalone object — enabling undo/redo, queuing, logging, and scheduling of operations. Complete Java guide: text editor with full undo history, the Invoker/Command/Receiver triad, macro commands, JDK usage (Runnable, Callable, CompletableFuture), and when it's worth the extra classes.
Chain of Responsibility passes a request along a chain of handlers until one handles it — decoupling sender from receiver. Complete Java guide: support ticket escalation example, fluent chain building, comparison with if-else chains, JDK usage (Servlet filters, logging), and when to use it vs a simple switch.
The Proxy pattern places a surrogate in front of an object — intercepting calls to add lazy loading, access control, logging, or remote delegation without touching the real object. Complete Java guide: virtual proxy, logging proxy, proxy chaining, dynamic proxy with java.lang.reflect.Proxy, Spring AOP connection, and when each proxy type is the right fit.