Facade Design Pattern in Java

The Facade Design Pattern is a structural design pattern that provides a simplified interface to a complex system of classes, interfaces, and objects. The Facade Design Pattern is used to provide a simple and easy-to-use interface to a complex system by hiding the complexity of the system from the user.

In Java, the Facade Design Pattern has the following properties:

Simplifies the interface: The Facade pattern simplifies the interface to a complex system by providing a simplified interface to the client. It hides the complexities of the system and provides a simple and easy-to-use interface.
Encapsulates subsystems: The Facade pattern encapsulates the subsystems of a complex system into a single class, which makes it easier to manage and maintain the system.
Improves modularity: The Facade pattern improves modularity by separating the client from the implementation details of the subsystems. This makes it easier to change the implementation of the subsystems without affecting the client.
Provides loose coupling: The Facade pattern provides loose coupling between the subsystems and the client. The client interacts with the subsystems through the Facade class, which decouples the client from the subsystems.
Promotes reusability: The Facade pattern promotes reusability by encapsulating the subsystems into a single class. The subsystems can be reused in other systems without affecting the implementation of the Facade class.

In Java, the Facade Design Pattern can be implemented in the following way:

Create a facade class that provides a simplified interface to the complex system. This facade class should have methods that the client can use to interact with the system.

public class Facade {
    private SubSystemA subSystemA;
    private SubSystemB subSystemB;
    private SubSystemC subSystemC;

    public Facade() {
        this.subSystemA = new SubSystemA();
        this.subSystemB = new SubSystemB();
        this.subSystemC = new SubSystemC();
    }

    public void methodA() {
        subSystemA.methodA();
    }

    public void methodB() {
        subSystemB.methodB();
    }

    public void methodC() {
        subSystemC.methodC();
    }
}

Create a set of subsystem classes that represent the complex system. These subsystem classes should not be directly accessible to the client.

public class SubSystemA {
    public void methodA() {
        System.out.println("SubSystemA methodA");
    }
}

public class SubSystemB {
    public void methodB() {
        System.out.println("SubSystemB methodB");
    }
}

public class SubSystemC {
    public void methodC() {
        System.out.println("SubSystemC methodC");
    }
}

Use the facade class to provide a simplified interface to the complex system.

public class Main {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.methodA();
        facade.methodB();
        facade.methodC();
    }
}

In this implementation, the client can use the Facade class to interact with the subsystems without having to know the details of the implementation of the subsystem classes. The Facade class acts as a simple interface to the complex system, making it easier for the client to use.

Share on Facebook

Save