Structural Design Patterns in Java

Remember that Adapter makes two existing interfaces work together as opposed to defining an entirely new one. Now you have been familiar with the basic patterns of Structural Design. I will explain the last main category in two different articles because Behavioral Design includes many patterns and it is better to split it into two articles. Sometimes a large number of independent extensions are possible and would produce an explosion of subclasses to support every combination. Or a class definition may be hidden or otherwise unavailable for sub-classing. Avoids permanent binding by removing the dependency between abstraction and implementation.

“Flyweight” pattern allows us to create a crowded object structure by creating visual objects from a sample object, rather than creating a large number of similar objects. First, we explain the “Adapter” which converts specific interfaces to compatible with other classes. After that, we mention the “Bridge” pattern that allows us to arrange both the interface and the application separately from each other. This design pattern hides the details of the system and offers a single front face for the client to access the system from the outside.

Adapter Pattern

Instead, you can use an existing design pattern to save time and effort. I hope you got a high-level idea of what a structural design pattern is, and what are its type. The adapter pattern helps in converting the interface of a class into another interface depending on the client’s requirements. So, basically providing what is required by the client by using the service of a class with a different interface.Adapter pattern is also famously known as Wrapper. The adapter pattern is a type of structural pattern which connects two related interface.

  • The Bridge pattern is used to segregate abstract classes from their implementations and act as a bridge between them.
  • In this post, we are going to discuss the Structural Design patterns as defined by the Gang of Four .
  • In other words, they define how objects interact with each other.
  • Class patterns expand the structures in software projects by combining class interfaces or applications by using inheritance.
  • The view and complex logic gets separated from each other.
  • The Decorator Pattern facilitates us when we need to extend the functionality of an object dynamically without having to change the original class source or using inheritance.

Structural patterns provide different ways to create a class structure, for example, using inheritance and composition to create a large object from small objects. The unified single interface is called the facade and itexposes only those limited functionalities that the client is interested in. Theimplementation details of the exposed functionalities are also hidden from the client. The Decorator Design Pattern is a structural pattern that lets usattach additional functionalities to a class instance during runtime ,without modifying the class structure. It provides an alternative to subclassing and promotes code reusability. The Bridge Design Pattern helps us toseparate an interfacefrom its implementerclass so that both entities can vary independently.

One thought on “Structural Design Patterns In Java”

This kind of structure allows you to keep the original object’s interface intact while still being able to modify its behavior. ProxyProxy is a type of structural design pattern that let you come up with a replacement or substitute for another object. Structural design patterns explain how to assemble objects and classes into larger structures, while keeping these structures flexible and efficient. In the Bridge Pattern, we separate an abstraction and its implementation and develop separate inheritance structures for both the abstraction and the implementer.

Structural Design Patterns

In the implementation part, there are simpler operations that are related to these higher-level operations and detail them. This is usually done by the class that «owns» the group of objects and provides a set of methods to treat them equally as if they were a single object. This pattern is often used in computer programming when an application needs to interface with an external system that uses a different API. Creational design patterns– These are patterns thatdeal with object creation. As a software engineer, it’s important to be well-versed in design patterns.


Base Component – Base component is the interface for all objects in the composition. Client program uses base component to work with the objects in the composition. Moreover, it can be an interface or an abstract class with some methods common to all the objects.Leaf – Defines the behavior for the elements in the composition. It is the building block for the composition and implements base component.

If you want to learn more about the Adapter pattern, see a real-world code example, then check outthis article. As with all design patterns, choosing the correct pattern for the job is important. Using the wrong pattern can lead to a design that is hard to understand and maintain. A design pattern is a repeatable solution to a commonly occurring problem in software development.

Therefore, developers must choose the right pattern for the job, as using the wrong one can lead to a design that is hard to understand or maintain. The Facade pattern can make a system easier to use, but it can also make it harder to change or extend. If the facade class is not designed properly, it can become tightly coupled to the subsystem and challenging to change. That’s why you need to be careful when designing the facade class so that it doesn’t become too tightly coupled to the subsystem. The Decorator pattern is also helpful for adding logging or performance monitoring capabilities to an object without changing the original implementation. The Composite pattern lets you treat the composite object and its components in the same way.

A class adapter accomplishes this by inheriting privately from an adaptee class. The adapter then expresses its interface in terms of the adaptee’s. This design pattern is quite powerful and helpful in understanding/establishing the relationship among the huge number of classes. By using this proxy class, the client uses the interface it defines, to access the original class.

Types of structural design patterns

For example, which class will be inherited by which class. How classes and interfaces are linked with each other and all other things related to the relationship between classes. This pattern is used to separate abstraction and implementation into class hierarchies. There is a class upon both the abstraction part and the implementation part. Here, the pattern is named as a “Bridge” between the two parts. In the abstraction part, there are higher-level operations of the system.

Structural Design Patterns

Proxy Lets you provide a substitute or placeholder for another object. A proxy controls access to the original object, allowing you to perform something either before or after the request gets through to the original object. In software engineering, are design patterns that ease the design by identifying a simple way to realize relationships between entities.

In turn, it forwards these calls to the underlying object. The Decorator object adds some additional functionality before or after forwarding requests to the underlying object. This ensures that the additional functionality can be added to a given object externally at runtime without python design patterns modifying its structure. For example, let’s assume an organization hierarchy in terms of the Composite Pattern. Let’s assume Manager as Composite, Employee as Component, and Developer as the Leaf. It has all common operations that will be applicable to both manager and developer.

Is a type of structural design pattern that allows us to compose objects into tree-like structures and then operate with these structures as if they were single objects. Structural design pattern is a blueprint of how different objects and classes are combined together to form a bigger structure for achieving multiple goals altogether. The patterns in structural designs show how unique pieces of a system can be combined together in an extensible and flexible manner. So, with the help structural design pattern we can target and change a specific parts of the structure without changing the entire structure. There are following 7 types of structural design patterns. Structural design patterns are concerned with how classes and objects can be composed, to form larger structures.


The customer now wants to keep away the Product class from the User class, as they want to use the User and Product class independently. This is actually a structural change and we don’t want this structural change to affect our project. Behavioral design patterns– These are patterns that deal with the communication between objects. In other words, they define how objects interact with each other. Another book related to design patterns that is very popular isHead First Design Patterns. It explains the design patterns in a very casual and interesting way.

When to use the Decorator Design Pattern

Because the cost of using a large number of objects is high. It is necessary to keep lightweight objects in a collection. If the states of these objects are low, the number of common objects is reduced. The Bridge pattern is used to segregate abstract classes from their implementations and act as a bridge between them.

The mediator design pattern may look very similar to the facade design pattern in terms of abstraction. Sometimes, there could be a scenario when two objects don’t fit together, as they should in order to get the work done. For example, this situation may arise when we try to integrate a legacy code with a new code, or when changing a 3rd party API in the code.

Bridge pattern

In this post, we are going to discuss the Structural Design patterns as defined by the Gang of Four . Structural patterns form larger structures from individual parts, generally of different classes. Structural Design Patterns are those Software Design Patternsin which the focus is on the relationship between classes and objects. It is more focused on the structure of the hierarchy of classes.

In simple terms composite pattern allows you to create hierarchical tree of unique complexities which allows treating every object individually. Reusability of the application also increases through the use of structural design pattern. Mediator is similar to Facade in that it abstracts functionality of existing classes.

For example, let’s create three classes named Class1, Class2, and Class3. Then, we need to simplify interaction with this system of classes so that clients can interact with these classes in a simple and standardized manner. It emphasizes one most important aspect of design which is an abstraction.