Facade design pattern can be applied at any point of development, usually when the number of interfaces grow and system gets complex. By working through a facade, now we can make changes to the subsystem classes without affecting the client code. Facade design pattern is another pattern from structural design pattern category. The Façade Design Pattern defines a higher-level interface that makes the subsystem easier to use. Besides a much simpler interface, there's one more benefit of using this design pattern. This pattern introduces a component called facade, which is a simplified interface component. In simple words, we can say that the Facade Design Pattern is used to hide the complexities of a system and provides an interface to the client using which the client can access the system. This facade simplifies the responsibilities of the client by standing between the complex sub-systems. Whether to use Facade or not is completely dependent on client code. Simply put, a facade encapsulates a complex subsystem behind a simple interface. Also, if we need to use the complex subsystem directly, we still can do that; we aren't forced to use the facade all the time. Facade is a structural design pattern that provides a simplified interface to a library, a framework, or any other complex set of classes. Facade is a structural design pattern that provides a simplified (but limited) interface to a complex system of classes, library or framework. The Facade design pattern is a structural pattern as it defines a manner for creating relationships between classes or entities. Facade design pattern is more like a helper for client applications, it doesnât hide subsystem interfaces from the client. In short, we make clients loosely coupled with the subsystem classes. It hides much of the complexity and makes the subsystem easy to use. Facade pattern is classified as a structural design pattern. Structuring a system into subsystems helps reduce complexity. Learn ⦠The Facade pattern is a way of providing a simple way for the clients to interact with the subsystems. A design pattern is a general reusable solution to a commonly occurring problem within a given context in software design. If we try to understand this in simpler terms, then we can say that a room is a façade and just by looking at it from outside the door, one can not predict what is inside the room and how the room is structured from inside. One way to achieve this goal is to introduce a "facade" object that provides a single, simplified interface to the many, potentially complex, individual interfaces within the subsystem. This supports loose coupling by hiding the complex details via a simple interface. The facade design pattern is used to define a simplified interface to a more complex subsystem. A common design goal is to minimize the communication and dependencies between subsystems. While Facade decreases the overall complexity of the application, it also helps to move unwanted dependencies to one place. This design patterns is all about Class and Object composition.