Top 50 Java Design Patterns Interview Questions and Answers

Q: Which design pattern is mostly used in Java

divThe Singleton pattern is one of the most popular design patterns in Java It ensures that a class has only one instance and gives a single point of access to that instance which is frequently used to manage shared resources such as database connections or configuration settingsdiv

Q: What are the three categories of design patterns in Java

divThere are three types of design patterns in Java creational structural and behavioral Creational patterns address object creation procedures structural patterns address object composition and behavioral patterns define object interaction and communicationdiv

Q: What is the principle of design pattern in Java

divThe purpose of design patterns in Java is to provide reusable solutions to common software design problems while promoting code maintainability flexibility and scalability through best practices such as encapsulation modularity and separation of concernsdiv

18 Sep 2024

Beginner

750 Views

93 min read

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 Design Pattern tutorial, I'll cover the top 50 Java Design Patterns interview questions and answers in which we will cover three categories for beginners, intermediate, and experienced. Here, we will try to cover all important aspects of design patterns and their types.

Java Design Patterns

Top 15 Java Design Patterns Interview Questions and Answers For Intermediate

21. What are the drawbacks of using the Singleton pattern?

While it serves some purposes well, there are several drawbacks of the Singleton pattern:

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?

Encapsulation of Object Creation: It centralizes object creation logic in a factory, making it easy to change, extend, or replace without altering client code.
Loose Coupling: Clients depend on abstractions (interfaces or base classes) rather than specific implementations, enabling easier swapping of implementations.
Scalability: New types of objects can be introduced by modifying the factory, without modifying existing code, promoting easy extension.

Example

// Vehicle Interface (Product)
interface Vehicle {
    void drive();
}

// Concrete implementation: Car
class Car implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Driving a car.");
    }
}

// Concrete implementation: Bike
class Bike implements Vehicle {
    @Override
    public void drive() {
        System.out.println("Riding a bike.");
    }
}

// Factory class to create vehicles
class VehicleFactory {
    // Factory method to create vehicle instances based on type
    public static Vehicle createVehicle(String vehicleType) {
        if (vehicleType.equalsIgnoreCase("Car")) {
            return new Car();
        } else if (vehicleType.equalsIgnoreCase("Bike")) {
            return new Bike();
        } else {
            throw new IllegalArgumentException("Invalid vehicle type.");
        }
    }
}

// Client code
public class Main {
    public static void main(String[] args) {
        // Create a Car using the factory
        Vehicle myCar = VehicleFactory.createVehicle("Car");
        myCar.drive();  // Output: Driving a car.

        // Create a Bike using the factory
        Vehicle myBike = VehicleFactory.createVehicle("Bike");
        myBike.drive();  // Output: Riding a bike.
    }
}

Output

Driving a car.
Riding a bike.

Explanation

In this example,

Vehicle Interface: Represents a generic vehicle.
Car and Bike: Concrete implementations of the Vehicle interface.
VehicleFactory: Contains the logic to instantiate and return objects based on input (Car or Bike).
Main Class: Demonstrates how to use the factory to create different vehicle objects.

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

The Observer Design Pattern can be applied in various real-world scenarios where one object (the subject) needs to notify other objects (observers) of changes in its state without tightly coupling them. Below is a common real-world application:

Example

Weather Monitoring System: A weather station (subject) needs to notify multiple devices (observers) like displays and apps whenever the temperature changes.


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

// Observer Interface
interface Observer {
    void update(float temperature);
}

// Subject (Weather Station)
class WeatherStation {
    private List<Observer> observers = new ArrayList<>();
    private float temperature;

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

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void setTemperature(float temperature) {
        this.temperature = temperature;
        notifyObservers();
    }

    private void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature);
        }
    }
}

// Concrete Observer: Display Device
class DisplayDevice implements Observer {
    private String name;

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

    @Override
    public void update(float temperature) {
        System.out.println(name + " display: Current temperature is " + temperature + "°C");
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        WeatherStation weatherStation = new WeatherStation();

        // Creating and adding observers
        Observer display1 = new DisplayDevice("Front Room");
        Observer display2 = new DisplayDevice("Back Room");
        weatherStation.addObserver(display1);
        weatherStation.addObserver(display2);

        // Change in temperature
        weatherStation.setTemperature(25.5f);  // All displays will be notified
    }
}

Output

Front Room display: Current temperature is 25.5°C
Back Room display: Current temperature is 25.5°C

Explanation

In this example,

WeatherStation: Subject that maintains a list of observers and notifies them of temperature changes.
DisplayDevice: Concrete observer that updates its display based on the temperature.
Main: Demonstrates adding observers and updating the temperature, showing how all observers are notified.

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

The role of the template method design pattern are:

Define Algorithm: Provides a skeleton for an algorithm in a base class.
Allow Extensions: Subclasses implement specific steps of the algorithm, allowing customization.
Promote Reuse: Reuses the common algorithm structure while allowing subclasses to vary specific parts.
Control Flow: Ensures the algorithm’s structure is consistent while enabling variations in the implementation details.

Example

We have a base class,CoffeeTemplate,that outlines the steps to make coffee, with some steps implemented in a concrete subclass.

// Abstract class with template method
abstract class CoffeeTemplate {

    // Template method defining the algorithm
    public final void makeCoffee() {
        boilWater();
        brewCoffeeGrinds();
        pourInCup();
        addCondiments();
    }

    // Steps that subclasses can implement
    protected abstract void brewCoffeeGrinds();
    protected abstract void addCondiments();

    // Common steps implemented in the base class
    private void boilWater() {
        System.out.println("Boiling water.");
    }

    private void pourInCup() {
        System.out.println("Pouring coffee into cup.");
    }
}

// Concrete subclass for making Coffee
class Coffee extends CoffeeTemplate {

    @Override
    protected void brewCoffeeGrinds() {
        System.out.println("Dripping coffee through filter.");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding sugar and milk.");
    }
}

// Concrete subclass for making Tea
class Tea extends CoffeeTemplate {

    @Override
    protected void brewCoffeeGrinds() {
        System.out.println("Steeping the tea.");
    }

    @Override
    protected void addCondiments() {
        System.out.println("Adding lemon.");
    }
}

// Main class
public class Main {
    public static void main(String[] args) {
        CoffeeTemplate coffee = new Coffee();
        coffee.makeCoffee();  // Output: Boiling water. Dripping coffee through filter. Pouring coffee into cup. Adding sugar and milk.

        CoffeeTemplate tea = new Tea();
        tea.makeCoffee();  // Output: Boiling water. Steeping the tea. Pouring coffee into cup. Adding lemon.
    }
}

Output

Boiling water.
Dripping coffee through filter.
Pouring coffee into cup.
Adding sugar and milk.
Boiling water.
Steeping the tea.
Pouring coffee into cup.
Adding lemon.

Explanation

In this example,

CoffeeTemplate: Defines the template method makeCoffee() with steps for making coffee or tea.
Coffee and Tea: Subclasses provide specific implementations for brewing and adding condiments.
Main: Demonstrates creating coffee and tea objects and calling makeCoffee(), which follows the template defined in the base class.

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

The Advantages of the Adapter Design Pattern are:

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?

The Strategy Design Patternchanges an object's behavior at runtime by encapsulating a family of algorithms into separate classes. This pattern allows an object to switch between different strategies (or algorithms) without altering the code that uses it.

Example

// Strategy Interface
interface PaymentStrategy {
    void pay(int amount);
}

// Concrete Strategy: CreditCardPayment
class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;

    public CreditCardPayment(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using Credit Card: " + cardNumber);
    }
}

// Concrete Strategy: PayPalPayment
class PayPalPayment implements PaymentStrategy {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public void pay(int amount) {
        System.out.println("Paying " + amount + " using PayPal account: " + email);
    }
}

// Context: PaymentProcessor
class PaymentProcessor {
    private PaymentStrategy paymentStrategy;

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

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

// Main class
public class Main {
    public static void main(String[] args) {
        PaymentProcessor processor = new PaymentProcessor();

        // Using Credit Card Payment Strategy
        PaymentStrategy creditCard = new CreditCardPayment("1234-5678-9876-5432");
        processor.setPaymentStrategy(creditCard);
        processor.processPayment(100);  // Output: Paying 100 using Credit Card: 1234-5678-9876-5432

        // Switching to PayPal Payment Strategy
        PaymentStrategy paypal = new PayPalPayment("user@example.com");
        processor.setPaymentStrategy(paypal);
        processor.processPayment(200);  // Output: Paying 200 using PayPal account: user@example.com
    }
}

Output

Paying 100 using Credit Card: 1234-5678-9876-5432
Paying 200 using PayPal account: user@example.com

Explanation

In this example,

PaymentStrategy: Defines a common interface for payment methods.
CreditCardPayment and PayPalPayment: Concrete strategies implementing the payment interface with specific behaviors.
PaymentProcessor: Context class that uses a PaymentStrategy object and can switch strategies dynamically.
Main: Demonstrates switching between different payment strategies at runtime.

27. What are the key components of the Builder Design Pattern?

There are five key components ofthe builderDesign Pattern:

1. Builder Interface

Defines the steps required to build the parts of a complex object.
Provides methods for creating different parts of the product.

2. Concrete Builder

Implements the Builder interface.
Constructs and assembles the parts of the product.
Keeps track of the product's current state.

3. Product

Represents the complex object being constructed.
Consists of various parts or components that are assembled by the builder.

4. Director

Uses the Builder object to construct the product.
Defines the order in which the steps should be executed to build the product.

5. Client

Uses the Director and Builder to create the product.
Does not need to understand the details of how the product is assembled.

28. What is the proxy pattern, and what does it do?

The Proxy Design Pattern is a structural design pattern that provides a surrogate or placeholder for another object. It controls access to the real object and can perform additional actions such as lazy initialization, access control, logging, or caching.

Main Functions of the Proxy Pattern

Access Control: The proxy can control access to the RealSubject, e.g., by implementing security checks.
Lazy Initialization: The proxy can delay the creation of the RealSubject until it is actually needed, improving performance.
Logging: The proxy can log access to the RealSubject, which is useful for monitoring or debugging.
Caching: The proxy can cache results from the RealSubject to optimize performance.

Example

// Subject Interface
interface Image {
    void display();
}

// Real Subject
class RealImage implements Image {
    private String filename;

    public RealImage(String filename) {
        this.filename = filename;
        loadImageFromDisk();
    }

    private void loadImageFromDisk() {
        System.out.println("Loading " + filename);
    }

    @Override
    public void display() {
        System.out.println("Displaying " + filename);
    }
}

// Proxy
class ProxyImage implements Image {
    private RealImage realImage;
    private String filename;

    public ProxyImage(String filename) {
        this.filename = filename;
    }

    @Override
    public void display() {
        if (realImage == null) {
            realImage = new RealImage(filename);
        }
        realImage.display();
    }
}

// Client code
public class Main {
    public static void main(String[] args) {
        Image image1 = new ProxyImage("image1.jpg");
        Image image2 = new ProxyImage("image2.jpg");

        // Image is loaded only when display() is called
        image1.display(); // Output: Loading image1.jpg, Displaying image1.jpg
        image2.display(); // Output: Loading image2.jpg, Displaying image2.jpg
        image1.display(); // Output: Displaying image1.jpg (no loading)
    }
}

Output

Loading image1.jpg
Displaying image1.jpg
Loading image2.jpg
Displaying image2.jpg
Displaying image1.jpg

Explanation

In this example,

Image: The common interface for RealImage and ProxyImage.
RealImage: The actual object that performs the heavy lifting.
ProxyImage: Manages access to RealImage, adding lazy initialization.
Main: Demonstrates how the proxy delays the loading of the image until it is needed.

29. How is the bridge pattern different from the adapter pattern?

Aspects	Bridge Pattern	Adapter Pattern
Purpose	Separates abstraction from implementation, allowing them to vary independently.	Converts the interface of a class into another interface that a client expects.
Components	Involves an abstraction (interface) and its implementation (details).	Involves an interface that needs adaptation and an adapter that translates it.
Use Case	Useful when needing to extend both the abstraction and implementation independently.	Useful when integrating incompatible interfaces or classes into a system.
Example	An abstract Shape class with different DrawingAPI implementations (e.g., drawing on different platforms).	Adapting a Rectangle class to fit into an IShape interface expected by a client.
Focus	Decoupling the interface and implementation.	Making incompatible interfaces compatible.

30. Explain the Data Access Object (DAO) Design Pattern?

The Data Access Object (DAO) Design Pattern is a structural pattern that separates the data access logic from the business logic of an application. It provides an abstract interface for accessing data, which allows the rest of the application to interact with the data source (such as a database) without knowing the details of how the data is stored and retrieved.

Abstracts Data Access: Provides an interface to interact with the data source, hiding implementation details.
Encapsulates CRUD Operations: Standardizes methods for creating, reading, updating, and deleting data.
Separates Concerns: Keeps data access code separate from business logic for better maintainability.
Supports Multiple Implementations: Allows different data sources or storage mechanisms to be used interchangeably.
Facilitates Testing: Enables easier unit testing by using mock implementations of the DAO interface.

31. How would you use the Prototype Design Pattern to clone objects?

The Prototype Design Pattern creates copies of objects without needing to know their specific classes. This pattern is particularly useful when creating new instances of objects is costly or complex.

Key steps involved:

Define a Prototype Interface:Create an interface that declares a clone method. This method is responsible for copying the object.
Implement the Prototype: Create concrete classes that implement the prototype interface. Implement the clone method to provide a way to duplicate the object.
Client Code: Use the clone method to create new objects based on an existing prototype.

Example

// Prototype interface
 interface Prototype {
    Prototype clone();
}

// Concrete prototype class
class ConcretePrototype implements Prototype {
    private String name;

    // Constructor
    public ConcretePrototype(String name) {
        this.name = name;
    }

    // Getter
    public String getName() {
        return name;
    }

    // Setter
    public void setName(String name) {
        this.name = name;
    }

    // Implement the clone method
    @Override
    public Prototype clone() {
        // Create a new instance with the same name
        return new ConcretePrototype(this.name);
    }
}

// Main class to demonstrate the Prototype Pattern
public class Main {
    public static void main(String[] args) {
        // Create an original object
        ConcretePrototype original = new ConcretePrototype("Original");

        // Clone the original object
        ConcretePrototype clone = (ConcretePrototype) original.clone();

        // Display the results
        System.out.println("Original Object Name: " + original.getName());
        System.out.println("Cloned Object Name: " + clone.getName());
    }
}

Output

Original Object Name: Original
Cloned Object Name: Original

Explanation

Prototype Interface: Prototype defines the clone method for cloning objects.
ConcretePrototype: Implements the Prototype interface. The clone method creates a new instance of ConcretePrototype with the same name as the original object.
Main Class: Creates an instance of ConcretePrototype, clones it, and prints the names of both the original and cloned objects.

32. What are the benefits of using the Visitor Design Pattern?

Here are the benefits of using the Visitor Design Pattern in short bullet points:

Separation of Concerns: It distinguishes algorithms from the objects on which they work. This enables you to introduce new actions without altering current classes.

Improved Maintainability: By separating the actions from the object structure, the code is easier to maintain and extend. Changes to operations do not alter the object structure, and vice versa.

Versatility in Integrating Operations: Additional operations can be introduced without affecting existing object structures. This makes it easier to add new features or functionality.

Consistent Interface: It provides a consistent interface for conducting operations on various sorts of objects, hence improving the coherence of actions on distinct pieces in the object structure.

33. Explain the role of the Mediator Design Pattern?

The roles of the mediator design pattern are:

Centralizes Communication: Manages and centralizes interactions between objects, reducing direct dependencies between them.
Simplifies Object Interaction: Facilitates communication between complex sets of objects by defining a mediator object that handles all interactions.
Reduces Coupling: Decouples components, making it easier to change or extend them independently without affecting others.
Encapsulates Communication Logic: Encapsulates the communication logic in the mediator, promoting cleaner and more maintainable code.
Improves Control and Coordination: Provides a single point of control for complex interactions, improving coordination and managing object states more effectively.

34. Describe a scenario where the Facade Design Pattern can be applied.

Scenario: Online Shopping System

Imagine an online shopping system where a customer can place an order. This system might involve multiple subsystems such as inventory management, payment processing, and shipping services. Each subsystem has its own complex interface and operations.

Example

// Inventory subsystem
class InventoryService {
    public void checkStock(String item) {
        System.out.println("Checking stock for " + item);
    }
}

// Payment subsystem
class PaymentService {
    public void processPayment(String paymentDetails) {
        System.out.println("Processing payment with details: " + paymentDetails);
    }
}

// Shipping subsystem
class ShippingService {
    public void arrangeShipping(String address) {
        System.out.println("Arranging shipping to " + address);
    }
}

// Facade class
class OrderFacade {
    private InventoryService inventoryService;
    private PaymentService paymentService;
    private ShippingService shippingService;

    public OrderFacade() {
        inventoryService = new InventoryService();
        paymentService = new PaymentService();
        shippingService = new ShippingService();
    }

    public void placeOrder(String item, String paymentDetails, String address) {
        inventoryService.checkStock(item);
        paymentService.processPayment(paymentDetails);
        shippingService.arrangeShipping(address);
        System.out.println("Order placed successfully!");
    }
}

// Main class to demonstrate the Facade Pattern
public class Main {
    public static void main(String[] args) {
        // Create a facade instance
        OrderFacade orderFacade = new OrderFacade();

        // Place an order using the simplified facade interface
        orderFacade.placeOrder("Laptop", "Credit Card", "123 Main St, Anytown, USA");
    }
}

Output

Checking stock for Laptop
Processing payment with details: Credit Card
Arranging shipping to 123 Main St, Anytown, USA
Order placed successfully!

Explanation

In this example

Subsystems: Handle different aspects of the system but have complex interfaces.
Facade: OrderFacade provides a simplified method placeOrder to handle complex interactions with the subsystems.
Client Code: Uses the OrderFacade to place an order without needing to interact with each subsystem directly.

35. What is the difference between Value Object (VO) and Java Data Object (JDO)?

Aspect	Value Object (VO)	Java Data Object (JDO)
Purpose	Represents a descriptive piece of data for transfer.	Manages persistent storage of Java objects.
Immutability	Typically immutable, once created, its state cannot change.	Mutable; managed for persistence in a data store.
Equality	Equality is based on the value of attributes.	Equality is based on object identity or database row identity.
Usage	Used to transfer data between different parts of a system.	Used for storing and retrieving objects from a database.
Integration	Not related to databases or persistence.	Directly related to database operations and mapping.
Example	java public class Address { private final String street; ... }	java import javax.jdo.annotations.*; @PersistenceCapable public class Person { ... }

Top 15 Java Design Patterns Interview Questions and Answers For Experienced

36. How would you implement a thread-safe Singleton in Java?

There are several approaches to implementing a thread-safe Singleton in Java. Below are two of the most common methods:

1. Using synchronized keyword (Lazy Initialization)

This method ensures that the Singleton instance is created only when it's needed, and the synchronized keyword guarantees thread safety.

2. Double-Checked Locking (Efficient and Thread-Safe)

This method improves performance by minimizing the use of synchronized, which is only used when the instance is null. After the instance is created, the synchronized block is bypassed.


class Singleton {

    // Constructor with package-private (default) visibility
    Singleton() {
        System.out.println("Singleton Instance Created");
    }

    // Static inner class responsible for holding Singleton instance
    static class SingletonHelper {
        static final Singleton INSTANCE = new Singleton();
    }

    // Method to provide access to the Singleton instance
    static Singleton getInstance() {
        return SingletonHelper.INSTANCE;
    }

    // Method to demonstrate Singleton behavior
    void showMessage() {
        System.out.println("Hello from Singleton!");
    }
}

public class Main {
    public static void main(String[] args) {
        // Getting the singleton instance
        Singleton singleton1 = Singleton.getInstance();
        singleton1.showMessage();

        // Getting the singleton instance again
        Singleton singleton2 = Singleton.getInstance();
        singleton2.showMessage();

        // Checking if both instances are the same
        if (singleton1 == singleton2) {
            System.out.println("Both instances are the same (Singleton pattern working correctly)");
        } else {
            System.out.println("Instances are different (Singleton pattern failed)");
        }
    }
}

Output

Singleton Instance Created
Hello from Singleton!
Hello from Singleton!
Both instances are the same (Singleton pattern working correctly)

Explanation

In this example,

Lazy Initialization: The Singleton instance is created only when the getInstance() method is called for the first time.
Thread Safety: The class is loaded on the first call to getInstance(), and class loading is thread-safe in Java.

37. Explain the Data Access Object (DAO) pattern?

Data Access Object (DAO) pattern is a structural pattern that provides an abstract interface to interact with a database or any other persistence storage. It encapsulates all the data access logic, allowing the business logic to interact with the persistence layer without needing to know the details of how the data is stored or retrieved.

Abstraction: The DAO pattern separates the business logic from the data access logic by creating a layer dedicated to CRUD operations (Create, Read, Update, Delete).

Encapsulation: The pattern encapsulates database access logic, making the business layer independent of the data source.

Reusability: By separating the data access logic, the DAO pattern promotes reuse and makes it easier to switch between different data sources or persistence mechanisms.

Maintainability: Changes to the data source (e.g., moving from a relational database to NoSQL) are localized to the DAO classes, minimizing changes needed in other parts of the application.

Testability: The DAO pattern makes unit testing easier because the business logic can be tested independently of the persistence layer.

38. Explain the use of the Observer pattern in a real-time monitoring system?

The Observer Design Pattern is used to create a one-to-many relationship between objects. It allows an object, called the "subject," to notify a list of observers (or "listeners") automatically whenever there is a change in its state, without the subject having to know who the observers are.

Real-Time Monitoring System Example: Server Health Monitoring System

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

// Observer interface
interface Observer {
    void update(String healthStatus);
}

// Subject interface
interface Subject {
    void addObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers();
}

// Server class which is the subject being observed
class Server implements Subject {
    private List<Observer> observers;
    private String serverHealth;

    public Server() {
        this.observers = new ArrayList<>();
    }

    public void setServerHealth(String health) {
        this.serverHealth = health;
        notifyObservers();
    }

    public String getServerHealth() {
        return serverHealth;
    }

    @Override
    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(serverHealth);
        }
    }
}

// Concrete Observer: Admin
class Admin implements Observer {
    private String adminName;

    public Admin(String name) {
        this.adminName = name;
    }

    @Override
    public void update(String healthStatus) {
        System.out.println("Admin " + adminName + " notified. Server Health: " + healthStatus);
    }
}

// Concrete Observer: Logging System
class LoggingSystem implements Observer {
    @Override
    public void update(String healthStatus) {
        System.out.println("Logging System: Server health status updated to: " + healthStatus);
    }
}

// Main class to demonstrate the real-time monitoring system using the Observer pattern
public class RealTimeMonitoringSystem {
    public static void main(String[] args) {
        // Create the subject (server) being observed
        Server server = new Server();

        // Create observers
        Admin admin1 = new Admin("Alice");
        Admin admin2 = new Admin("Bob");
        LoggingSystem loggingSystem = new LoggingSystem();

        // Register observers with the server
        server.addObserver(admin1);
        server.addObserver(admin2);
        server.addObserver(loggingSystem);

        // Simulate server health changes
        System.out.println("Changing server health to: Healthy");
        server.setServerHealth("Healthy");

        System.out.println("Changing server health to: Unstable");
        server.setServerHealth("Unstable");

        System.out.println("Changing server health to: Critical");
        server.setServerHealth("Critical");

        // Unregister an observer (Admin2) and update server health
        server.removeObserver(admin2);
        System.out.println("Changing server health to: Down");
        server.setServerHealth("Down");
    }
}

Out[ut

Changing server health to: Healthy
Admin Alice notified. Server Health: Healthy
Admin Bob notified. Server Health: Healthy
Logging System: Server health status updated to: Healthy
Changing server health to: Unstable
Admin Alice notified. Server Health: Unstable
Admin Bob notified. Server Health: Unstable
Logging System: Server health status updated to: Unstable
Changing server health to: Critical
Admin Alice notified. Server Health: Critical
Admin Bob notified. Server Health: Critical
Logging System: Server health status updated to: Critical
Changing server health to: Down
Admin Alice notified. Server Health: Down
Logging System: Server health status updated to: Down

Explanation

In this example,

The Server class represents the system being monitored (the subject).
The Admin and LoggingSystem classes are concrete observers that listen for changes in the server’s health.
When the server’s health changes (e.g., from "Healthy" to "Unstable"), it automatically notifies all registered observers (admins and the logging system) using the notifyObservers() method.
Admins and the logging system receive real-time updates without needing to manually check the server’s status.

Use cases of the Observer Pattern

The Observer pattern is ideal for systems that need to broadcast state changes to multiple objects, such as server monitoring, where various subsystems or users (admins, logging systems, dashboards) need real-time notifications.
It decouples the subject (server) from the observers, making the system more flexible and easier to maintain. New observers can be added or removed without changing the subject’s logic.

39. What are the MVC patterns?

The Model-View-Controller (MVC) pattern is a software architectural pattern used for building user interfaces. It divides an application into three interconnected components: Model (data and business logic), View (UI representation), and Controller (handles user input and interactions).

Model: Manages data and business logic, interacting with the database.
View: Displays the data from the model to the user, handling the UI layer.
Controller: Interprets user inputs, updating the model or the view as necessary.
Separation of Concerns: Each component has a specific role, making the application modular and easier to maintain.
Reusability: Changes to the view or model can be made independently, enhancing flexibility.

40. Explain some different types of proxies.

There are numerous instances where the proxy pattern is advantageous. Let's look at a few different proxies:

1. Protection proxy

A Protection Proxy controls access to an object by adding a layer of authorization, ensuring that only authorized users or operations can access certain methods or data.
It acts as a gatekeeper, preventing unauthorized access by validating requests before forwarding them to the actual object.

2. Virtual proxies

Virtual proxies are utilized to create the pricey object.
The proxy in the implementation manages the true subject's lifetime.
It determines the requirement for instance creation and when to reuse it.
Virtual proxies improve performance.

3. Caching Proxies

Caching proxies are used to save expensive calls to the actual subject.
There are numerous caching mechanisms that the proxy can employ.
Many of them are read-through, write-through, cache-aside, and time-dependent.
Caching proxies are used to improve performance.

4. Remote proxies

A Remote Proxy provides a local representative for an object that resides in a different address space, typically on a different machine or server, enabling interaction with it as if it were local.
It handles the communication, serialization, and network complexities between the client and the remote object, simplifying distributed computing.

5. Smart Proxies

A Smart Proxy adds extra functionality to the object it represents, such as caching, logging, or access control, before forwarding requests to the actual object.
It can enhance performance, track usage, or manage additional services without altering the original object’s implementation.

41. How would you use the Command Design Pattern to implement an undo feature?

The Command Design Pattern is ideal for implementing an undo feature because it encapsulates a request as an object. This allows you to parameterize clients with queues, requests, and operations and to support undo functionality.

Steps to Implement Undo with the Command Pattern

Define Command Interface: Create an interface for commands that includes methods for executing and undoing the command.
Create Concrete Commands: Implement concrete command classes that encapsulate the operations and their corresponding undo logic.
Maintain Command History: Keep a stack or list of executed commands to enable undo functionality.
Invoker: Use an invoker to execute commands and store them in history. It also handles the undo operation by calling the undo method on the last executed command.
Receiver: The receiver is the object that performs the actual work of the command.

import java.util.Stack;

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

// Receiver class
class TextEditor {
    private StringBuilder text = new StringBuilder();

    public void write(String str) {
        text.append(str);
    }

    public void undoWrite(String str) {
        int start = text.length() - str.length();
        if (start >= 0) {
            text.delete(start, text.length());
        }
    }

    @Override
    public String toString() {
        return text.toString();
    }
}

// Concrete Command for writing text
class WriteCommand implements Command {
    private TextEditor editor;
    private String text;

    public WriteCommand(TextEditor editor, String text) {
        this.editor = editor;
        this.text = text;
    }

    @Override
    public void execute() {
        editor.write(text);
    }

    @Override
    public void undo() {
        editor.undoWrite(text);
    }
}

// Invoker class
class CommandManager {
    private Stack<Command> history = new Stack<>();

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

    public void undo() {
        if (!history.isEmpty()) {
            Command command = history.pop();
            command.undo();
        }
    }
}

// Main class to demonstrate the Command Pattern with undo feature
public class CommandPatternDemo {
    public static void main(String[] args) {
        TextEditor editor = new TextEditor();
        CommandManager commandManager = new CommandManager();

        Command writeHello = new WriteCommand(editor, "Hello ");
        Command writeWorld = new WriteCommand(editor, "World!");

        // Execute commands
        commandManager.executeCommand(writeHello);
        commandManager.executeCommand(writeWorld);
        System.out.println("Editor Content: " + editor);

        // Undo the last command
        commandManager.undo();
        System.out.println("Editor Content after undo: " + editor);

        // Undo the next command
        commandManager.undo();
        System.out.println("Editor Content after second undo: " + editor);
    }
}

Output

Editor Content: Hello World!
Editor Content after undo: Hello 
Editor Content after second undo:

Explanation

In this example,

Command Interface: Defines methods for execute and undo.
Concrete Command: Implements specific operations and their undo logic.
Invoker: Manages command execution and maintains a history stack for undo functionality.
Receiver: Performs the actual operations, like writing and undoing text.
Client: Executes commands and performs undo operations via the CommandManager.

42. What is the impact of the Flyweight pattern on system performance?

The impact of the Flyweight pattern on system performance are:

Reduced Memory Usage: By sharing common objects rather than creating new instances, the Flyweight pattern minimizes memory consumption, particularly when dealing with large numbers of similar objects.

Improved Performance: Reduces overhead associated with creating and managing multiple similar objects, leading to more efficient resource utilization and faster execution.

Enhanced Scalability: Helps systems scale better by avoiding the performance hit of instantiating and maintaining numerous objects, particularly in environments with high object creation rates.

Encapsulation of Shared Data: Centralizes and manages shared data, reducing duplication and inconsistencies while simplifying maintenance.

Increased Complexity: Introduces additional complexity in managing the shared objects and their intrinsic and extrinsic states, which can complicate design and debugging.

43. How can the Visitor pattern be used to implement operations on a file system?

The Visitor design pattern effectively implements operations on a file system by separating the algorithm from the objects on which it operates.

Steps to Use Visitor Pattern for File System Operations:

1. Define the Element Interface: Create an interface or abstract class for file system elements (e.g., File and Directory), which includes an accept method that takes a Visitor.

2. Create Concrete Elements:Implement the File and Directory classes, each with an accept method that invokes the appropriate visit method on the Visitor.

3. Define the Visitor Interface: Create an interface for visitors that defines a visit method for each type of element (e.g., visitFile and visitDirectory).

4. Implement Concrete Visitors: Implement concrete visitor classes that perform specific operations (e.g., PrintVisitor for printing details, SizeVisitor for calculating total size).

5. Use Visitors: Apply visitors to file system elements to perform operations without altering the element classes.

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

// Element interface
interface FileSystemElement {
    void accept(Visitor visitor);
}

// File class
class File implements FileSystemElement {
    private String name;
    private int size;

   public File(String name, int size) {
        this.name = name;
        this.size = size;
    }

   String getName() {
        return name;
    }

    int getSize() {
        return size;
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visitFile(this);
    }
}

// Directory class
class Directory implements FileSystemElement {
    private String name;
    private List<FileSystemElement> elements = new ArrayList<>();

    Directory(String name) {
        this.name = name;
    }

    void addElement(FileSystemElement element) {
        elements.add(element);
    }

    String getName() {
        return name;
    }

    List<FileSystemElement> getElements() {
        return elements;
    }

    @Override
    public void accept(Visitor visitor) {
        visitor.visitDirectory(this);
    }
}

// Visitor interface
interface Visitor {
    void visitFile(File file);
    void visitDirectory(Directory directory);
}

// Visitor for printing file system structure
class PrintVisitor implements Visitor {
    @Override
    public void visitFile(File file) {
        System.out.println("File: " + file.getName() + ", Size: " + file.getSize() + " bytes");
    }

    @Override
    public void visitDirectory(Directory directory) {
        System.out.println("Directory: " + directory.getName());
        for (FileSystemElement element : directory.getElements()) {
            element.accept(this);
        }
    }
}

// Visitor for calculating total size
class SizeVisitor implements Visitor {
    private int totalSize = 0;

    @Override
    public void visitFile(File file) {
        totalSize += file.getSize();
    }

    @Override
    public void visitDirectory(Directory directory) {
        for (FileSystemElement element : directory.getElements()) {
            element.accept(this);
        }
    }

    int getTotalSize() {
        return totalSize;
    }
}

// Main class to demonstrate the Visitor Pattern with file system operations
class VisitorPatternDemo {
    public static void main(String[] args) {
        File file1 = new File("file1.txt", 100);
        File file2 = new File("file2.txt", 200);
        Directory directory = new Directory("myDirectory");
        directory.addElement(file1);
        directory.addElement(file2);

        // Use PrintVisitor to print the file system structure
        Visitor printVisitor = new PrintVisitor();
        directory.accept(printVisitor);

        // Use SizeVisitor to calculate total size
        SizeVisitor sizeVisitor = new SizeVisitor();
        directory.accept(sizeVisitor);
        System.out.println("Total size: " + sizeVisitor.getTotalSize() + " bytes");
    }
}

Output

Directory: myDirectory
 File: file1.txt, Size: 100 bytes
 File: file2.txt, Size: 200 bytes
 Total size: 300 bytes

Explanation

In this example,

FileSystemElement Interface: Defines an accept() method for elements (files or directories) that accept a Visitor.
File and Directory Classes: File represents individual files, while Directory represents a collection of FileSystemElement objects. Both implement FileSystemElement.
Visitor Interface: Defines methods visitFile() and visitDirectory() for performing operations on File and Directory elements.
PrintVisitor and SizeVisitor: Implement the Visitor interface. PrintVisitor prints the structure, and SizeVisitor calculates the total size of files in the system.
Main Method (VisitorPatternDemo): Demonstrates the use of both PrintVisitor and SizeVisitor to print the structure and calculate the total size of the files in a directory.

44. What is the purpose of the Memento Design Pattern?

The purpose of the Momento Design Pattern are:

Undo/Redo operations: Allow objects to revert to a previous state when needed.
Encapsulation: Protect an object's internal state from external access while still enabling restoration.
State history tracking: Record and revert state changes over time in applications like text editors, game development, etc.

45. How can the Chain of Responsibility pattern be optimized in a large system?

The Chain of Responsibility (CoR) pattern can be optimized in a large system using the following techniques:

Use a lookup mechanism: Instead of traversing the entire chain, use a lookup table or a map to quickly find the appropriate handler, reducing unnecessary iterations.

Conditional shortcuts: Implement checks to exit the chain early if a condition is met or if it's clear the chain can be skipped for certain inputs.

Lazy initialization: Delay the creation of handlers until they are actually needed, which reduces memory usage and speeds up initialization.

Parallel handling: In cases where order is not important, process multiple handlers in parallel to improve response time.

Caching: Cache results of previously handled requests to prevent reprocessing similar requests and speed up handling.

46. How can the State pattern simplify state management in a complex application?

The State design pattern simplifies state management in a complex application by:

Encapsulating state-specific behavior: It separates each state into its own class, making the logic for each state easier to manage and modify.

Eliminating large conditional statements: Instead of using complex if-else or switch conditions to handle state transitions, the pattern dynamically changes the object's behavior by delegating state-specific tasks to state objects.

Making state transitions explicit: State changes are clearly managed through transitions between state objects, improving code readability and maintainability.

Promoting scalability: New states can be easily added without modifying existing code, ensuring the system can scale efficiently.

Reducing code duplication: By centralizing state-related logic into separate classes, common behavior can be shared or reused, leading to cleaner code.

47. What are the limitations of the Command Design Pattern?

The Command Design Pattern may create numerous limitations:

Increased number of classes: Each command requires its own class, which can lead to a large number of additional classes, increasing the complexity of the system.

Higher memory usage: Storing commands for potential undo/redo functionality can increase memory consumption, especially in systems with many commands.

Complexity in command management: Managing the lifecycle of commands (e.g., undo/redo, logging) can add complexity to the system, requiring additional infrastructure.

Hard to maintain: With many command types, maintaining and understanding the relationships between them can become more challenging.

Overhead for simple operations: Using the Command pattern for very basic or trivial operations may add unnecessary overhead to the design.

48. How does the Decorator Design Pattern promote code reusability?

The Decorator Design Pattern promotes code reusability in the following ways:

Flexible functionality extension: It allows new behavior to be added to objects dynamically without modifying their code, promoting the reuse of existing classes.

Composition over inheritance: Instead of creating numerous subclasses to add features, decorators can be combined and applied in different orders, making the code more modular and reusable.

Single Responsibility: Each decorator focuses on a single piece of functionality, making it easier to reuse specific behaviors independently across multiple objects

Open/Closed Principle: Classes can be extended without changing their original implementation, making the system adaptable and maintainable.

49. Explain how the Interpreter pattern can be used in a simple calculator application.

The Interpreter Design Pattern can be used in a simple calculator application by defining a grammar for arithmetic expressions and implementing classes to interpret different operations like addition, subtraction, etc.

Below is an example in Java that demonstrates how you can implement this pattern in a simple calculator.

// Define the Expression interface
interface Expression {
    int interpret();
}

// Terminal Expression for numbers
class NumberExpression implements Expression {
    private int number;

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

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

// Non-Terminal Expression for addition
class AddExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public AddExpression(Expression left, Expression right) {
        this.leftExpression = left;
        this.rightExpression = right;
    }

    @Override
    public int interpret() {
        return leftExpression.interpret() + rightExpression.interpret();
    }
}

// Non-Terminal Expression for subtraction
class SubtractExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;

    public SubtractExpression(Expression left, Expression right) {
        this.leftExpression = left;
        this.rightExpression = right;
    }

    @Override
    public int interpret() {
        return leftExpression.interpret() - rightExpression.interpret();
    }
}

// Main class to test the Interpreter pattern
public class Calculator {
    public static void main(String[] args) {
        // Represents the expression (5 + 3) - 2
        Expression expression = new SubtractExpression(
            new AddExpression(new NumberExpression(5), new NumberExpression(3)),
            new NumberExpression(2)
        );

        // Interpret and print the result
        System.out.println("Result: " + expression.interpret());
    }
}

Output

Result: 6

Explanation

In this example

The Expression interface defines the interpret() method, which is implemented by all expression classes.
NumberExpression represents a number and returns its value.
AddExpression and SubtractExpression are used to combine other expressions.
The Calculator class constructs the expression tree for (5+3)-2 and prints the results.

50. What are the advantages of using the Bridge Design Pattern?

The Bridge Design Pattern provides various advantages:

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 do not affect 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

This article provides a curated selection of the top 50 Java design pattern interview questions and answers for beginners, intermediate, and experienced developers. It covers a wide spectrum of design patterns, from the basics like Singleton and Factory to more complex ones like Flyweight and Proxy. Each component is intended to help developers, regardless of experience level, improve their comprehension and confidently respond to design pattern questions in interviews. To master design patterns, enroll in ScholarHat's Master Software Architecture and Design Certification Training.

FAQs

The Singleton pattern is one of the most popular design patterns in Java. It ensures that a class has only one instance and gives a single point of access to that instance, which is frequently used to manage shared resources such as database connections or configuration settings.

There are three types of design patterns in Java: creational, structural, and behavioral. Creational patterns address object creation procedures, structural patterns address object composition, and behavioral patterns define object interaction and communication.

The purpose of design patterns in Java is to provide reusable solutions to common software design problems while promoting code maintainability, flexibility, and scalability through best practices such as encapsulation, modularity, and separation of concerns.

01 Beginner

02 Intermediate

03 Questions

04 Training Programs

Top 50 Java Design Patterns Interview Questions and Answers

⭐ .NET Design Patterns Course: Design Patterns in C# Online Training

Java Design Patterns

Top 20 Java Design Patterns Interview Questions and Answers For Beginners

1. What is a design pattern in Java?

2. Explain the Singleton Design Pattern?

3. When would you use the Factory Design Pattern?

4. What is the Observer Design Pattern?

5. Can you describe the Decorator Design Pattern?

6. Explain the Adapter Design Pattern.

7. What is the Strategy Design Pattern?

8. What is the Template Method Pattern?

9. How does the Prototype Design Pattern work?

10. Describe the Chain of Responsibility Pattern.

Definition

Usage

Example

11. What is the Command Design Pattern?

12. Explain the Flyweight Design Pattern.

13. What is the Facade Design Pattern?

14. Describe the Bridge Design Pattern.

15. What is the Composite Design Pattern?

16. How does the Mediator Design Pattern work?

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

18. Describe the uses of the Composite Design Pattern.

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

Top 15 Java Design Patterns Interview Questions and Answers For Intermediate

21. What are the drawbacks of using the Singleton pattern?

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

Example

Output

Explanation

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

Example

Output

Explanation

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

Example

Output

Explanation

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

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

Example

Output

Explanation

27. What are the key components of the Builder Design Pattern?

1. Builder Interface

2. Concrete Builder

3. Product

4. Director

5. Client

28. What is the proxy pattern, and what does it do?

Main Functions of the Proxy Pattern

Example

Output

Explanation

29. How is the bridge pattern different from the adapter pattern?

30. Explain the Data Access Object (DAO) Design Pattern?

31. How would you use the Prototype Design Pattern to clone objects?

Key steps involved:

Example

Output

Explanation

32. What are the benefits of using the Visitor Design Pattern?

33. Explain the role of the Mediator Design Pattern?

34. Describe a scenario where the Facade Design Pattern can be applied.

Scenario: Online Shopping System

Example

Output

Explanation

35. What is the difference between Value Object (VO) and Java Data Object (JDO)?

Top 15 Java Design Patterns Interview Questions and Answers For Experienced

36. How would you implement a thread-safe Singleton in Java?

1. Using synchronized keyword (Lazy Initialization)

2. Double-Checked Locking (Efficient and Thread-Safe)

Output