Top 50 Java Design Patterns Interview Questions and Answers

Java Design Patterns

Java Design Patterns are useful in software development because they provide tested answers to common problems. They support developers in creating code that is easier to maintain, understand, and expand.

In this Java tutorial, I'll cover the top 50 Java Design Patterns interview questions and answers, including 20 for beginners, 15 for intermediate developers, and another 15 for experienced experts. This will help you completely prepare for any Java Design Patterns interviews you may face.

Top 20 Java Design Patterns Interview Questions and Answers For Beginners

1. What is a design pattern in Java?

• A design pattern is a reusable solution to common issues in software design.
• It gives a proven framework for addressing specific issues and can assist developers in writing efficient and maintainable code.

2. Explain the Singleton Design Pattern.

• The Singleton Design Pattern assures that a class only has one instance across the application while also providing a global access point to that instance.
• This is important for managing shared resources such as configuration settings or logging systems and maintaining consistency and limited access throughout a program. Let's understand with a simple example.

Example

public class Logger {
    // The single instance of the Logger
    private static Logger instance;

    // Private constructor to prevent instantiation
    private Logger() {}

    // Method to provide access to the single instance
    public static Logger getInstance() {
        if (instance == null) {
            instance = new Logger();
        }
        return instance;
    }

    // Example method to log messages
    public void log(String message) {
        System.out.println("Log: " + message);
    }

    public static void main(String[] args) {
        // Get the single instance of Logger
        Logger logger = Logger.getInstance();

        // Use the logger to log messages
        logger.log("Singleton pattern example");
    }
}

Output

Log: Singleton pattern example

Explanation

• The program uses the Singleton design pattern. The Logger class ensures that only one logger instance is created throughout the program.
• It exposes a static function getInstance() to access this single instance.
• The log() method sends log messages to the console. The main method logs a message, demonstrating how the singleton logger can be used to capture data.

3. When would you use the Factory Design Pattern?

• It is the most often used design pattern in Java.
• These design patterns fall under the Creational Pattern, which provides one of the finest ways to construct an object.
• In the Factory pattern, we do not expose the creation logic to the client. Instead, we refer to the generated object using a standard interface.
• The Factory Pattern allows sub-classes to select the sort of object to produce.
• The Factory Pattern is often referred to as Virtual Constructor.

4. What is the Observer Design Pattern?

The Observer pattern allows items to communicate with each other. It's similar to telling others about something and everyone knowing what's going on. It is used when multiple objects need to be notified when something occurs to one object.

To apply the Observer Pattern, we have to:

• Define an interface for Observer objects that specifies which method(s) will be invoked when the monitored object's state changes.
• Create an interface for the Subject (observed) object that allows Observer objects to register, remove, and be notified about changes.
• Create concrete Observer classes that implement the Observer interface and have their implementation of the Update method.
• Create a concrete Subject class that implements the Subject interface and stores a list of registered Observer objects.
• This class also includes methods for changing the state of an object, which sends alerts to all registered Observers.

5. Can you describe the Decorator Design Pattern?

The Decorator pattern allows you to add new features to an object while keeping its appearance and functionality intact. You create a new class that wraps around the existing object and adds new functionality to it. To apply the Decorator Pattern, we have to:

• Create an interface or abstract class that specifies the methods that both the original object and the decorator must implement.
• Create a concrete class that implements the interface or abstract class while representing the actual item.
• Create a decorator class that implements the same interface or abstract class and includes an instance of the original object.
• Apply the interface or abstract class's methods in the decorator class by calling the right methods on the original object instance and adding new features.

6. Explain the Adapter Design Pattern.

The Adapter pattern allows diverse items to operate together, even if they were not designed to do so. It transforms one item into another, allowing them to collaborate. This is useful when two things are incompatible but must coexist.

To apply the adapter pattern, we have to:

• Identify the interface that the client intends to utilize.
• Identify the current interface that has to be modified to meet the goal interface.
• Construct an Adapter class that defines the target interface and includes an instance of the current interface.
• Create the target interface's methods in the Adapter class by calling the appropriate methods on the existing interface instance.

7. What is the Strategy Design Pattern?

The Strategy Design Pattern is a type of behavioral design that defines a set of algorithms, encapsulates them, and allows them to be used interchangeably. It enables a client to select an algorithm from a family of algorithms at runtime, increasing flexibility and allowing the algorithm to change independently of the client that utilizes it.

To apply the Strategy Pattern, we have to:

• Define a strategy interface that specifies the method(s) for the algorithm.
• Create concrete strategy classes that implement this interface with specific algorithm details.
• Define a context class that holds a reference to a strategy object and invokes the algorithm through the strategy interface.
• Allow the context class to change the strategy object at runtime, providing the flexibility to use different algorithms as needed.

8. What is the Template Method Pattern?

The Template Method pattern is a design pattern that allows you to create a list of steps to complete a task, but some of the stages can be completed in multiple ways. You begin by creating a basic list of steps, and then you create a primary step that instructs the other phases to execute. Each stage can be unique, yet they all work together to accomplish the desired result.

To apply the Template Pattern, we have to:

• Create an abstract base class that includes a template function. The template method should invoke additional methods (abstract or concrete) to carry out specified algorithmic processes.
• Define abstract methods in the base class to represent the steps that subclasses must complete.
• Create concrete subclasses that implement the abstract methods to give step-specific implementations.
• Client code can generate a concrete subclass instance and perform the algorithm using the template method.

9. How does the Prototype Design Pattern work?

The Prototype Design Pattern is a creational design pattern that allows objects to be duplicated or cloned rather than developed from the start, much like creating a replica of an existing item. It is used to efficiently construct duplicate objects while avoiding the overhead associated with initializing new instances.

To apply the Prototype Pattern, we have to:

• Define a prototype interface that declares a method for cloning itself.
• Create concrete prototype classes that implement the prototype interface and define how they should be cloned.
• Define a client class that uses the prototype objects to create new instances by cloning existing ones.
• Ensure that the cloning process is efficient and accurately replicates the original object's state.

10. Describe the Chain of Responsibility Pattern.

The Chain of Responsibility Pattern is a behavioral design pattern in which an object delegates a request along a chain of potential handlers. Here is a brief overview:

Definition

• This pattern uncouples the sender of a request from its receivers by giving a chain of objects to process it.
• Each handler in the chain decides either to process the request or to pass it down the chain.

Usage

• When you want to allow multiple objects to handle a request and pass the request along a chain of handlers.
• It is especially useful in cases where an exact handler is not known a priori and when different handlers need to be included based on either the type of request or conditions.

Example

• Think of a customer support service in which requests can be of different kinds, say a problem related to billing, technical issues, or just general information.
• A request for support comes in and is passed along the chain of departments until the appropriate one is capable of processing it.

This design pattern makes the system more flexible and dynamic, where new handlers can be easily added without changing existing code.

11. What is the Command Design Pattern?

The Command pattern is a method for organizing and controlling requests in a computer program.Instead of delivering direct instructions, we express and execute our requests using objects known as commands.

This allows us to utilize various requests for different clients, maintain track of prior requests, and undo earlier operations.

We describe how commands should be executed using an interface or class, and then we design different classes to represent different types of commands.

To apply the Command Pattern, we're going to have to:

• Create a Command interface or abstract class to define the execute method.
• Create concrete classes that use the Command interface to represent various commands. These classes should contain a reference to the receiver object that will carry out the command.
• Create an invoker class that will run the instructions by calling their execute function.
• Client code should construct and pass concrete Command instances to the invoker class.

12. Explain the Flyweight Design Pattern.

The Flyweight Design Pattern is a structural design pattern that reduces memory usage by sharing common elements of things. It is especially beneficial when working with a large number of things that have many similarities but differ in a few ways. Sharing common data and creating lightweight objects helps reduce the overhead of memory consumption and improve performance.

To apply the Flyweight Pattern, we have to:

• Define a Flyweight interface that declares methods for interacting with shared and intrinsic data.
• Create concrete Flyweight classes that implement the Flyweight interface and manage the shared (extrinsic) data.
• Define a Flyweight Factory that maintains a pool of existing Flyweight objects and provides a method to retrieve or create them.
• Ensure that clients use the Flyweight Factory to get Flyweight instances, passing only the extrinsic data to manage the variations in state.

13. What is the Facade Design Pattern?

The Facade Design Pattern is a kind of Structural Design Pattern that provides a simplified interface to a complex subsystem, allowing it to be easily used. It mostly comprises the creation of a single class called the "facade," which provides an instance through which all the set of interfaces from the subsystems can be accessed. Then, the complex details of the subsystem are hidden from the client.

To apply the Facade Pattern, we have to:

• Define a Facade class that presents a simple, unified interface to the subsystem.
• Encapsulate the complexity of the subsystem by including references to the subsystem classes within the Facade.
• Implement methods in the Facade class, which calls upon the corresponding subsystem classes to execute the client's requests.
• The Facade class is meant to interact with the subsystem so that it simplifies the interaction of the client and decreases dependency on the behavior of the subsystem.

14. Describe the Bridge Design Pattern.

The Bridge Design Pattern lies within structural design patterns. It decouples the abstraction from the implementation and thus allows the two to vary independently. It is an abstraction layer through which you can vary the abstraction part and the implementation part independently.

To apply the Bridge Pattern, we have to:

• Define an abstraction class that contains a reference to an implementation interface and provides methods for interacting with it.
• Create an implementation interface that declares methods for the concrete implementations to define.
• Create concrete implementations that implement the implementation interface and provide specific functionality.
• Implement concrete abstractions that extend the abstraction class and delegate calls to the implementation interface, allowing the abstraction to use different implementations.

15. What is the Composite Design Pattern?

The Composite Design Pattern is a Structural Design Pattern that allows objects to be composed in tree-like structures to represent part-whole hierarchies. The client should be able to treat both individual objects and compositions of objects uniformly, which will make it easy for clients to use these complicated tree structures.

To apply the Composite Pattern, we have to:

• Define a component interface that declares common methods for leaf and composite objects.
• Create leaf classes that implement the component interface and represent the basic elements of the structure.
• Create composite classes that implement the component interface and contain a collection of child components (both leaf and other composites).
• Implement methods in the composite classes to manage child components, allowing clients to treat both individual objects and compositions uniformly.

16. How does the Mediator Design Pattern work?

The Mediator Design Pattern manages complex communications and controls interactions among objects in a system. It centralizes communication among objects, thereby not letting them tighten the coupling and reducing dependencies. Here's how it works:

1. Central Mediator: It defines an interface for communication between objects. Objects do not communicate with each other directly; rather, they interact through the mediator.
2. Colleagues: These are the objects that wish to communicate. They direct their requests to the mediator instead of addressing them directly to each other.
3. Decoupling: The usage of the mediator helps to decouple objects from each other, which leads to less maintenance and a certain degree of flexibility.

17. How is the Bridge pattern different from the Adapter pattern?

• The Adapter design aims to make interfaces of one or more classes look comparable.
• The Bridge pattern is intended to separate a class's interface from its implementation, allowing us to alter or replace the way it is implemented without changing the client code.

18. Describe the uses of the Composite Design Pattern.

Use Cases

• When we want to show a partial or complete hierarchy of items.
• If we need to add responsibilities dynamically to a particular object without affecting other objects.

19. What are Some Design Patterns used in the JDK library?

• Wrapper classes employ the decorator pattern.
• Calendar classes (runtime) employ the singleton pattern.
• Wrapper classes, like Integer, use a factory pattern.valueOf.
• Swing and Abstract Window Toolkit (AWT) are examples of event-handling frameworks that use the observer approach.

20. What are the essential points to keep in mind for the Flyweight Design Pattern?

• This design pattern can be complex, requiring a lot of memory and time. As a result, it is critical to exercise caution when using it.
• This Pattern is ineffective when the Object's intrinsic attributes are huge. It can increase the complexity of the process.

Top 15 Java Design Patterns Interview Questions and Answers For Intermediate

• Hidden Dependencies: This creates a global instance that all parts of the code must rely on, making dependencies less obvious and therefore managing the code becomes harder.
• Testing Problems: Singletons can be hard to mock or isolate in unit tests; this often leads to less effective and more coupled test cases.
• Concurrency Issues: The Singleton instance must be carefully synchronized in multi-threaded environments to make sure there is no multiple instantiation or bottleneck in performance.
• Nonflexibility: It enforces a single instance, which can be problematic if the application needs to handle multiple instances or adapt to changed future requirements.

22. How does the Factory Design Pattern improve code flexibility?

Example

public abstract class ScholarHatCourse {
    public abstract void deliver();
}

public class JavaCourse extends ScholarHatCourse {
    @Override
    public void deliver() {
        System.out.println("Delivering Java Course");
    }
}

public class PythonCourse extends ScholarHatCourse {
    @Override
    public void deliver() {
        System.out.println("Delivering Python Course");
    }
}

public class CourseFactory {
    public ScholarHatCourse getCourse(String courseType) {
        if (courseType.equals("Java")) {
            return new JavaCourse();
        } else if (courseType.equals("Python")) {
            return new PythonCourse();
        }
        return null;
    }
}

Output

Delivering Java Course
Delivering Python Course

Explanation

• The program illustrates a simple manufacturing pattern. The ScholarHatCourse abstract class defines the function deliver(), which must be implemented by its subclasses.
• JavaCourse and PythonCourse are concrete implementations that give specific behavior for the deliver() method.
• The CourseFactory class includes a getCourse() function that returns a ScholarHatCourse object based on the course type specified.
• This enables the construction of course objects without specifying a specific class.

23. How can the Observer Design Pattern be applied in a real-world scenario?

Example

import java.util.ArrayList;
import java.util.List;

public class ScholarHatSubject {
    private List observers = new ArrayList<>();
    private String state;

    public void addObserver(ScholarHatObserver observer) {
        observers.add(observer);
    }

    public void setState(String state) {
        this.state = state;
        notifyAllObservers();
    }

    public void notifyAllObservers() {
        for (ScholarHatObserver observer : observers) {
            observer.update();
        }
    }

    public String getState() {
        return state;
    }
}

public abstract class ScholarHatObserver {
    protected ScholarHatSubject subject;
    public abstract void update();
}

public class ScholarHatStudent extends ScholarHatObserver {
    public ScholarHatStudent(ScholarHatSubject subject) {
        this.subject = subject;
        this.subject.addObserver(this);
    }

    @Override
    public void update() {
        System.out.println("Student received update: " + subject.getState());
    }
}

output

Student received update: New Course Available
Student received update: New Course Available

Explanation

24. What is the role of the Template Method Design Pattern?

public abstract class ScholarHatCourseTemplate {
    public final void deliverCourse() {
        prepareMaterials();
        deliverLectures();
        conductAssessment();
    }

    protected abstract void prepareMaterials();
    protected abstract void deliverLectures();
    protected abstract void conductAssessment();
}

public class JavaCourse extends ScholarHatCourseTemplate {
    @Override
    protected void prepareMaterials() {
        System.out.println("Preparing Java course materials.");
    }

    @Override
    protected void deliverLectures() {
        System.out.println("Delivering Java lectures.");
    }

    @Override
    protected void conductAssessment() {
        System.out.println("Conducting Java assessment.");
    }
}

Preparing Java course materials.
Delivering Java lectures.
Conducting Java assessment.

• This code defines a course delivery sequence using the Template Method pattern.
• The deliverCourse() method in ScholarHatCourseTemplate invokes three abstract methods: prepareMaterials(), deliverLectures(), and conductAssessment().
• These methods are implemented specifically in the JavaCourse class. When deliverCourse() is called on a JavaCourse instance, it displays the steps required to prepare and deliver a Java course.

25. Explain the advantages of using the Adapter Design Pattern.

• Adaptable: The Adapter Design Pattern overcomes the incompatibility between interfaces by taking an interface of one class and converting it into another interface, one expected by the client, that way making formerly incompatible systems work together seamlessly.
• Reusability:The existing code can already be reused for a new system without any modification to the original code. That will help to reduce the duplication and rework of already existing codes and systems.
• Flexibility: Adapters can be easily changed or replaced without changing the client code, thus enabling flexibility to attach different components or systems as per changing requirements.
• Decoupling: Reduces the dependency of client code on the subsystem by abstracting the integration logic and helps in producing much cleaner and more maintainable code.

26. How is the Strategy Design Pattern used to change the behavior of an object

Example

public interface PaymentStrategy {
    void pay(int amount);
}

public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card.");
    }
}

public class PayPalPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using PayPal.");
    }
}

public class ScholarHatShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void checkout(int amount) {
        paymentStrategy.pay(amount);
    }
}

Output

Paid 100 using Credit Card.
Paid 200 using PayPal.

Explanation

• This code exhibits the Strategy pattern for payment methods. The PaymentStrategy interface includes a pay() function.
• CreditCardPayment and PayPalPayment are tangible examples of this interface.
• The ScholarHatShoppingCart class handles payments using a PaymentStrategy.
• By configuring alternative payment techniques, the cart can process payments in a variety of ways, enabling flexibility and separating issues when handling payments.

public abstract class ScholarHatPrototype implements Cloneable {
    public ScholarHatPrototype clone() throws CloneNotSupportedException {
        return (ScholarHatPrototype) super.clone();
    }
}

public class ScholarHatCourse extends ScholarHatPrototype {
    private String courseName;

    public ScholarHatCourse(String courseName) {
        this.courseName = courseName;
    }

    @Override
    public String toString() {
        return "Course: " + courseName;
    }
}

public class Main {
    public static void main(String[] args) throws CloneNotSupportedException {
        ScholarHatCourse course1 = new ScholarHatCourse("Java Programming");
        ScholarHatCourse course2 = course1.clone();

        System.out.println(course1);
        System.out.println(course2);
    }
}

Course: Java Programming
Course: Java Programming

public class ScholarHatSingleton {
    private static ScholarHatSingleton instance;

    private ScholarHatSingleton() {}

    public static synchronized ScholarHatSingleton getInstance() {
        if (instance == null) {
            instance = new ScholarHatSingleton();
        }
        return instance;
    }
}

true

import java.util.ArrayList;
import java.util.List;

public class ScholarHatMonitoringSystem {
    private List observers = new ArrayList<>();
    private String status;

    public void addObserver(ScholarHatObserver observer) {
        observers.add(observer);
    }

    public void setStatus(String status) {
        this.status = status;
        notifyAllObservers();
    }

    private void notifyAllObservers() {
        for (ScholarHatObserver observer : observers) {
            observer.update();
        }
    }

    public String getStatus() {
        return status;
    }
}

public abstract class ScholarHatObserver {
    protected ScholarHatMonitoringSystem system;
    public abstract void update();
}

public class ScholarHatAlertSystem extends ScholarHatObserver {
    public ScholarHatAlertSystem(ScholarHatMonitoringSystem system) {
        this.system = system;
        this.system.addObserver(this);
    }

    @Override
    public void update() {
        System.out.println("Alert! System status changed: " + system.getStatus());
    }
}

Alert! System status changed: Critical Update Available

import java.util.Stack;

public interface Command {
    void execute();
    void undo();
}

public class ScholarHatLight {
    public void on() {
        System.out.println("Light is ON");
    }

    public void off() {
        System.out.println("Light is OFF");
    }
}

public class LightOnCommand implements Command {
    private ScholarHatLight light;

    public LightOnCommand(ScholarHatLight light) {
        this.light = light;
    }

    @Override
    public void execute() {
        light.on();
    }

    @Override
    public void undo() {
        light.off();
    }
}

public class RemoteControl {
    private Stack commandStack = new Stack<>();

    public void executeCommand(Command command) {
        command.execute();
        commandStack.push(command);
    }

    public void undoCommand() {
        if (!commandStack.isEmpty()) {
            commandStack.pop().undo();
        }
    }
}

Light is ON
Light is OFF

import java.util.ArrayList;
import java.util.List;

public interface FileElement {
    void accept(FileVisitor visitor);
}

public class ScholarHatFile implements FileElement {
    private String name;

    public ScholarHatFile(String name) {
        this.name = name;
    }

    @Override
    public void accept(FileVisitor visitor) {
        visitor.visit(this);
    }

    public String getName() {
        return name;
    }
}

public class ScholarHatDirectory implements FileElement {
    private String name;
    private List elements = new ArrayList<>();

    public ScholarHatDirectory(String name) {
        this.name = name;
    }

    public void addElement(FileElement element) {
        elements.add(element);
    }

    @Override
    public void accept(FileVisitor visitor) {
        for (FileElement element : elements) {
            element.accept(visitor);
        }
        visitor.visit(this);
    }
}

public interface FileVisitor {
    void visit(ScholarHatFile file);
    void visit(ScholarHatDirectory directory);
}

public class FileSizeVisitor implements FileVisitor {
    private int totalSize = 0;

    @Override
    public void visit(ScholarHatFile file) {
        totalSize += 1; // Assume each file has a size of 1 for simplicity.
    }

    @Override
    public void visit(ScholarHatDirectory directory) {
        // No size contribution for directories in this simple example.
    }

    public int getTotalSize() {
        return totalSize;
    }
}

public class Main {
    public static void main(String[] args) {
        ScholarHatDirectory root = new ScholarHatDirectory("root");
        ScholarHatFile file1 = new ScholarHatFile("file1.txt");
        ScholarHatFile file2 = new ScholarHatFile("file2.txt");

        root.addElement(file1);
        root.addElement(file2);

        FileSizeVisitor sizeVisitor = new FileSizeVisitor();
        root.accept(sizeVisitor);

        System.out.println("Total size: " + sizeVisitor.getTotalSize());
    }
}

Total size: 2

public interface Expression {
    int interpret();
}

public class Number implements Expression {
    private int number;

    public Number(int number) {
        this.number = number;
    }

    @Override
    public int interpret() {
        return number;
    }
}

public class Addition implements Expression {
    private Expression left;
    private Expression right;

    public Addition(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpret() {
        return left.interpret() + right.interpret();
    }
}

public class Main {
    public static void main(String[] args) {
        Expression expression = new Addition(new Number(5), new Number(10));
        System.out.println("Result: " + expression.interpret());
    }
}

Result: 15

• This code uses the Interpreter pattern. The Expression interface and its two implementations (Number and Addition) define and evaluate expressions.
• The Main class generates an Addition expression from Number objects and publishes the result, demonstrating how to create and evaluate complex expressions from smaller ones.

• Separation of Abstraction and Implementation: It isolates the abstraction from the implementation, allowing them to change independently. This is useful for managing complicated systems when changes in abstraction or implementation have no effect on each other.
• Increased Flexibility: It allows for the construction of new abstractions and implementations without changing existing code, enhancing flexibility and scalability.
• Enhanced Maintainability: By decoupling abstraction from implementation, code maintenance, and extension are simplified, making it easier to manage and update.
• Improved Code Reusability: It enables distinct implementations to be reused across several abstractions, eliminating code duplication and increasing reusability.

Summary