Design Patterns Interview Questions

A design pattern is a reusable solution to a common software design problem. It provides best practices for creating maintainable and scalable applications.

Design patterns are categorized into Creational, Structural, and Behavioral patterns.

Singleton ensures that only one instance of a class exists and provides a global access point to that instance.

A Singleton can be made thread-safe using synchronized methods, eager initialization, double-checked locking, or enum-based implementation.

Factory Pattern creates objects without exposing the object creation logic to the client.

Abstract Factory provides an interface for creating families of related objects without specifying their concrete classes.

Builder Pattern constructs complex objects step by step and separates object construction from representation.

Prototype Pattern creates new objects by cloning existing objects rather than creating them from scratch.

Adapter Pattern allows incompatible interfaces to work together by acting as a bridge between them.

Decorator Pattern dynamically adds new behavior to objects without modifying their existing structure.

Observer Pattern defines a one-to-many dependency where observers are automatically notified of changes in the subject.

Strategy Pattern defines a family of algorithms and allows them to be selected at runtime.

MVC separates an application into Model, View, and Controller components to improve maintainability.

Dependency Injection is a design pattern where dependencies are provided externally rather than created within a class.

Factory creates a single type of object, while Abstract Factory creates families of related objects.

Name concrete APIs (collections, concurrency, streams, annotations) tied to Design Patterns. Interviewers want syntax-level clarity plus when you would reach for each feature in production.

Prefer specific checked/unchecked exceptions, wrap lower-level failures with context, and avoid empty catch blocks. For Design Patterns, decide what is recoverable vs fatal to the request thread.

JUnit 5 with Arrange-Act-Assert, Mockito for collaborators, and parameterized tests for edge cases. Keep Design Patterns logic pure where possible so tests stay fast.

Incorrect equals/hashCode break HashMap/HashSet behavior. If Design Patterns stores objects in collections, explain the contract and mutability pitfalls.

Retain only needed references, prefer streaming for large datasets, and avoid accidental caches. Relate leaks or GC pressure to a concrete Design Patterns scenario.