Design Patterns in Java

What Are Design Patterns?

A design pattern is a reusable solution to a recurring design problem. Not a library you import, not a snippet you paste, but a template for structuring code that experienced developers have found works well in a particular context. The Gang of Four book, published in 1994, catalogued 23 patterns organized into three categories: creational (how objects are created), structural (how objects are composed), and behavioral (how objects communicate). These categories are still the standard way to discuss patterns.

The value of learning patterns is not that you will mechanically apply them everywhere. It is that patterns give you a shared vocabulary. When a colleague says "we should use an Observer here," you immediately understand the proposed structure without a lengthy explanation. Patterns also help you recognize when code is heading in a direction that has a known better solution.

Creational Patterns

Creational patterns deal with object creation. They abstract or defer the decision of which class to instantiate and how, making the system independent of how its objects are created and composed.

Singleton

Singleton ensures a class has exactly one instance and provides a global access point to it. The classic use cases are configuration managers, logging services, and thread pools: things that make no sense to have duplicated. The implementation must handle thread safety: two threads calling getInstance simultaneously without synchronization can each see the instance as null and create two objects.

The cleanest thread-safe Java implementation uses the enum idiom or the initialization-on-demand holder pattern. The enum approach is serialization-safe and reflection-safe as a bonus. Overuse is the main danger: Singletons are effectively global state. They make unit testing harder (you cannot inject a mock easily), they hide dependencies, and they cause subtle ordering bugs in multi-module systems.

Factory Method and Abstract Factory

The Factory Method pattern defines an interface for creating an object but lets subclasses decide which class to instantiate. The creator class calls a factory method instead of a constructor directly. Subclasses override the factory method to change the type being created. This is the pattern behind DocumentBuilderFactory.newDocumentBuilder() and countless other JDK and framework APIs.

Abstract Factory goes one level higher: it produces families of related objects. A UIFactory might produce a Button and a TextField that belong together. A DarkUIFactory produces dark-themed versions of both; a LightUIFactory produces light-themed versions. Switching the factory switches the entire family consistently without changing any consuming code.

Builder and Prototype

Builder addresses the telescoping constructor problem. When a class has many optional configuration parameters, the alternatives, overloaded constructors or a constructor with ten parameters, are either insufficient or unreadable. Builder provides a fluent API where you set only the fields you need, and a final build() call produces an immutable object. Frameworks like Lombok, OkHttp, and Guava's immutable collections use Builder extensively.

Prototype creates new objects by copying an existing instance rather than constructing from scratch. This is useful when object creation is expensive (database reads, complex initializations) and you need multiple similar objects. Java supports this through the Cloneable interface and the clone() method, though in modern code a copy constructor or a factory method is almost always preferred because clone() has well-known design problems.

Structural Patterns

Structural patterns deal with object composition. They describe ways to assemble objects and classes into larger structures while keeping those structures flexible and efficient.

Behavioral Patterns

Behavioral patterns deal with how objects communicate and cooperate. They distribute responsibility between objects in ways that make the system more flexible and easier to extend.

Java-specific Patterns

Immutable Class, DAO, and Dependency Injection

An immutable class is one whose state cannot change after construction. Every field is private and final, no setters are provided, mutable fields (like lists or arrays) are defensively copied in the constructor and again in any getter. Immutable objects are inherently thread-safe, can be shared freely, and make excellent keys for maps. Java's String, Integer, and all Java 9 List.of() collections are immutable.

The DAO (Data Access Object) pattern separates persistence code from business logic. A DAO interface declares the operations (find, save, delete). The business layer calls the interface. A concrete DAO implements it for a specific storage mechanism: SQL, NoSQL, a file, or an in-memory store. Swapping the data source means writing a new DAO implementation without touching any business code. Testing business logic means injecting an in-memory DAO instead of a real database.

Dependency Injection means that a class receives its dependencies from outside rather than creating them itself. This is the opposite of calling new inside a class body. Constructor injection is the preferred form: dependencies are passed as constructor parameters, making them explicit, mandatory, and easily testable. DI frameworks like Spring automate the wiring, but the pattern works perfectly well without a framework for smaller codebases.

SOLID Principles

SOLID is an acronym for five design principles that together produce code that is easier to maintain, extend, and test. They are principles, not rules: they guide judgment rather than mandate a specific structure.

Anti-patterns to Avoid

Anti-patterns are recurring design mistakes that look like solutions but introduce problems more serious than the one they appear to solve. Recognizing them by name helps teams communicate clearly about code quality issues.

Quiz - Test Your Knowledge

Ten questions covering creational patterns (Singleton, Builder, Factory), structural patterns (Adapter, Decorator, Proxy, Composite), behavioral patterns (Observer, Strategy, Chain of Responsibility), Java-specific patterns (Immutable, DAO, DI), the SOLID principles, and common anti-patterns. Read each option carefully before selecting your answer.