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.
The Flyweight pattern reduces memory usage by sharing common state between many fine-grained objects instead of duplicating it. 1,000 trees of 3 species need 3 shared objects, not 1,000. Complete Java guide: intrinsic vs extrinsic state, flyweight factory, forest rendering example, JDK usage (String pool, Integer cache), and when the overhead is worth it.
The Facade pattern provides a simple, unified interface to a complex subsystem — so callers get one method instead of orchestrating six classes themselves. Complete Java guide: video conversion example, when Facade is right vs when it's an anti-pattern, JDK examples (SLF4J, JDBC, javax.mail), and how to keep the subsystem accessible for power users.