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.
The Decorator pattern adds behaviour to an object by wrapping it in another object that shares the same interface — without subclassing. Stack as many layers as you need; order matters. Complete Java guide: text processor pipeline, base decorator pattern, JDK I/O streams explained, when Decorator beats inheritance, and every layer shown step by step.
The Composite pattern lets you treat individual objects and collections of objects through the same interface — so a single file and a directory full of files both answer getSize() the same way. Complete Java guide: file system tree example, recursive traversal, when Composite fits vs when it's overkill, and real JDK usage (Swing component hierarchy, JSX-style trees).
The Bridge pattern decouples abstraction from implementation so both can evolve independently. Without it, adding new device types and remote types requires N×M classes. With it: N+M. Complete Java guide: remote control example, when to use Bridge vs Adapter vs Strategy, real JDK usage (JDBC DriverManager, SLF4J), and the exact problem that makes you reach for it.
The Adapter pattern wraps an incompatible interface so it fits the one your code expects — without touching either side. Complete Java guide: Object Adapter vs Class Adapter, payment gateway example with full runnable code, JDK real-world usage (InputStreamReader, Arrays.asList), and when to reach for it vs redesigning your interfaces.
The Singleton pattern guarantees exactly one instance of a class — but Java's threading model, serialization, and reflection make it harder than it looks. Complete guide: all 6 implementations (Eager, Lazy, synchronized, DCL, Holder, Enum), thread-safety analysis, Spring singletons, pitfalls, and when NOT to use it.