Design Pattern: Composite Pattern

When there is a bunch of classes that are of the same type (implement the same interface), and we need to use them as composition (not as individual objects), we can use Composite pattern. Composite pattern helps to use the classes in a composition, so that the client can use the composition and individual classes can be tread in the same way.

Design Pattern: Decorator Pattern

In Decorator design pattern, our target is to add some new functionality to an existing object. Say, there is an existing class that is responsible for printing a UI element (like a Button or Table). Later we need the ability to add a border or text color to that element. We can add new properties and functions to that existing class and introduce those properties. But that will violate the Open-Close principle of the SOLID principle.

Design Pattern: Flyweight Pattern

As we need to generate a huge number of objects of the same class, so it will occupy a big amount of memory. To avoid that, we can create objects with only the required elements and keep that in a cache. As only the required properties are there so the number of objects will be smaller now. As the only difference between those objects is their extrinsic properties, we will pass those properties while using that specific object.

Design Pattern: Facade Pattern

Facade pattern adds a new layer to the system, on top of the underlying complex subsystems. This new layer works as an entry point for the client. The client can interact with this new layer, instead of communicating with the subsystems directly. That way the client does not need to be aware of the subsystems and gets a common interface.