Table of Contents
- Structural patterns control the relationships between large portions of your applications.
- Structural patterns affect applications in a variety of ways—for example, the Adapter pattern enables two incompatible systems to communicate, whereas the Façade pattern enables you to present a simplified interface to a user without removing all the options available in the system.
- Structural patterns enable you to create systems without rewriting or customizing the code.
- This provides the system with enhanced reusability and robust functionality.
- The structural patterns are Adapter, Bridge, Composite, Decorator, Façade, Flyweight, and Proxy (ABCDF2P).
1. Adapter Pattern
- The Adapter pattern acts as an intermediary between two classes, converting the interface of one class so that it can be used with the other. This enables classes with incompatible interfaces to work together.
- It implements an interface known to its clients and provides access to an instance of a class not known to its clients.
- An adapter object provides the functionality of an interface without having to know the class used to implement that interface.
Adapter Pattern: Diagram
Target – defines the domain-specific interface that Client uses.
Adapter – adapts the interface Adaptee to the Target interface.
Adaptee – defines an existing interface that needs adapting.
Client – collaborates with objects conforming to the Target interface.
Adapter Pattern: Benefits & When to Use
- Allows two or more incompatible objects to communicate and interact
- Improves reusability of older functionality
When to Use :
- You want to use an existing class, and its interface does not match the interface you need.
- You want to create a reusable class that cooperates with unrelated or unforeseen classes—that is, classes that don’t necessarily have compatible interfaces.
- Interface translation among multiple sources must occur.
2. Bridge Pattern
- It divides a complex component into two separate but related inheritance hierarchies: the functional abstraction and the internal implementation.
- This makes it easier to change either aspect of the component so that the two can vary independently.
- The Bridge pattern is useful when there is a hierarchy of abstractions and a corresponding hierarchy of implementations.
- Rather than combining the abstractions and implementations into many distinct classes, the Bridge pattern implements the abstractions and implementations as independent classes.
Bridge Pattern: Diagram
Bridge Pattern : Diagram
- Abstraction – defines abstraction interface.
- AbstractionImpl – Implements the abstraction interface using a reference to an object of type Implementor.
- Implementor – Implementor defines the interface for implementation classes. This interface does not need to correspond directly to the abstraction interface and can be very different. AbstractionImp provides an implementation in terms of operations provided by Implementor interface.
- ConcreteImplementor1, ConcreteImplementor2 – Implements the Implementor interface.
Bridge Pattern: Benefits & When to Use
- Enables you to separate the interface from the implementation
- Improves extensibility
- Hides implementation details from clients
When to Use:
- You want to avoid a permanent binding between an abstraction and its implementation.
- Both the abstractions and their implementations should be extensible using subclasses.
- Changes in the implementation of an abstraction should have no impact on clients; that is, you should not have to recompile their code.
3. Composite Pattern
- The Composite pattern enables you to create hierarchical tree structures of varying complexity while allowing every element in the structure to operate with a uniform interface.
- The Composite pattern combines objects into tree structures to represent either the whole hierarchy or a part of the hierarchy.
- This means the Composite pattern allows clients to treat individual objects and compositions of objects uniformly.
Composite Pattern: Diagram
Composite Pattern: participants
- Component – Component is the abstraction for leafs and composites. It defines the interface that must be implemented by the objects in the composition. For example a file system resource defines move, copy, rename, and getSize methods for files and folders.
- Leaf – Leafs are objects that have no children. They implement services described by the Component interface. For example a file object implements move, copy, rename, as well as getSize methods which are related to the Component interface.
- Composite – A Composite stores child components in addition to implementing methods defined by the component interface. Composites implement methods defined in the Component interface by delegating to child components. In addition composites provide additional methods for adding, removing, as well as getting components.
- Client – The client manipulates objects in the hierarchy using the component interface.
Composite Pattern: Benefits & When to use
- Defines class hierarchies consisting of primitive objects and composite objects
- Makes it easier to add new kinds of components
- Provides flexibility of structure and a manageable interface
When to Use:
- You want to represent the whole hierarchy or a part of the hierarchy of objects.
- You want clients to be able to ignore the difference between compositions of objects and individual objects.
- The structure can have any level of complexity.
4. Decorator Pattern
- The Decorator pattern enables you to add or remove object functionality without changing the external appearance or function of the object.
- It changes the functionality of an object in a way that is transparent to its clients by using an instance of a subclass of the original class that delegates operations to the original object.
- It attaches additional responsibilities to an object dynamically to provide a flexible alternative to changing object functionality without using static inheritance.
Decorator Pattern: Diagram
Decorator Pattern: Participants
- Component – Interface for objects that can have responsibilities added to them dynamically.
- ConcreteComponent – Defines an object to which additional responsibilities can be added.
- Decorator – Maintains a reference to a Component object and defines an interface that conforms to Component’s interface.
- Concrete Decorators – Concrete Decorators extend the functionality of the component by adding state or adding behavior.
Decorator Pattern: Benefits
The following lists the benefits of using the Decorator pattern:
- More flexibility than static inheritance
- Avoids feature-laden classes high up in the hierarchy
- Simplifies coding because you write a series of classes, each targeted at a specific part of the functionality, rather than coding all behavior into the object
- Enhances the object’s extensibility because you make changes by coding new classes
Decorator Pattern: When to Use
You should use the Decorator pattern when:
- You want to add responsibilities to individual objects dynamically and transparently—that is, without affecting other objects.
- You want to add responsibilities to the object that you might want to change in the future.
- Extension by static subclassing is impractical.
5. Façade Pattern
- The Façade pattern provides a unified interface to a group of interfaces in a subsystem.
- The Façade pattern defines a higher-level interface that makes the subsystem easier to use because you have only one interface.
- This unified interface enables an object to access the subsystem using the interface to communicate with the subsystem.
Façade Pattern: Diagram
Façade Pattern: Benefits
- Provides a simple interface to a complex system without reducing the options provided by the system
- Shields clients from subsystem components
- Promotes weak coupling between the subsystem and its clients
- Reduces coupling between subsystems if every subsystem uses its own Façade pattern and other parts of the system use the Façade pattern to communicate with the subsystem
- Translates the client requests to the subsystems that can fulfil those requests
Façade Pattern: When to Use
You should use the Façade pattern when:
- You want to provide a simple interface to a complex subsystem.
- There are many dependencies between clients and the implementation classes of an abstraction.
- You want to layer your subsystems.
6. Flyweight Pattern
- The Flyweight pattern reduces the number of low-level, detailed objects within a system by sharing objects.
- If instances of a class that contain the same information can be used interchangeably, the Flyweight pattern allows a program to avoid the expense of multiple instances that contain the same information by sharing one instance.
- Reduction in the number of objects to handle
- Reduction in memory and on storage devices, if the objects are persisted
Flyweight Pattern: Diagram
Flyweight Pattern: Participants
- Flyweight – Declares an interface through which flyweights can receive and act on extrinsic state.
- ConcreteFlyweight – Implements the Flyweight interface and stores intrinsic state. A ConcreteFlyweight object must be sharable. The Concrete flyweight object must maintain state that it is intrinsic to it, and must be able to manipulate state that is extrinsic. In the war game example graphical representation is an intrinsic state, where location and health states are extrinsic. Soldier moves, the motion behavior manipulates the external state (location) to create a new location.
- FlyweightFactory – The factory creates and manages flyweight objects. In addition the factory ensures sharing of the flyweight objects. The factory maintains a pool of different flyweight objects and returns an object from the pool if it is already created, adds one to the pool and returns it in case it is new.
- In the war example a Soldier Flyweight factory can create two types of flyweights : a Soldier flyweight, as well as a Colonel Flyweight. When the Client asks the Factory for a soldier, the factory checks to see if there is a soldier in the pool, if there is, it is returned to the client, if there is no soldier in pool, a soldier is created, added to pool, and returned to the client, the next time a client asks for a soldier, the soldier created previously is returned, no new soldier is created.
- Client – A client maintains references to flyweights in addition to computing and maintaining extrinsic state
Flyweight Pattern: When to Use
You should use the Flyweight pattern when all of the following are true:
- The application uses a large number of objects.
- Storage costs are high because of the number of objects.
- The application doesn’t depend on object identity.
7. Proxy Pattern
- The Proxy pattern provides a surrogate or placeholder object to control access to the original object.
- There are several types of implementations of the Proxy pattern, with the Remote proxy and Virtual proxy being the most common.
The following lists the benefits of using the Proxy pattern:
- A remote proxy can hide the fact that an object resides in a different address space.
- A virtual proxy can perform optimizations, such as creating an object on demand.
Proxy Pattern: Diagram
Proxy Pattern: Participants
- Subject – Interface implemented by the RealSubject and representing its services. The interface must be implemented by the proxy as well so that the proxy can be used in any location where the RealSubject can be used.
- Maintains a reference that allows the Proxy to access the RealSubject.
- Implements the same interface implemented by the RealSubject so that the Proxy can be substituted for the RealSubject.
- Controls access to the RealSubject and may be responsible for its creation and deletion. Other responsibilities depend on the kind of proxy.
- RealSubject – the real object that the proxy represents.
Proxy Pattern: When to Use
You should use the Proxy pattern when:
- You need a more versatile or sophisticated reference to an object than a simple pointer.
- Behavioural patterns influence how state and behaviour flow through a system.
- By optimizing how state and behaviour are transferred and modified, you can simplify, optimize, and increase the maintainability of an application.
- The Behavioral patterns are Chain of Responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, Strategy, Template Method, and Visitor
1. Chain of Responsibility Pattern
- The Chain of Responsibility pattern establishes a chain within a system, so that a message can either be handled at the level where it is firstreceived, or be directed to an object that can handle it.
Chain of Responsibility Pattern: Diagram
Chain of Responsibility Pattern: Participants
- Handler – defines an interface for handling requests
- ConcreteHandler – handles the requests it is responsible for If it can handle the request it does so, otherwise, it sends the request to its successor
- Client – sends commands to the first object in the chain that may handle the command
Chain of Responsibility Pattern: Benefits
The following lists the benefits of using the Chain of Responsibility pattern:
- Reduced coupling
- Added flexibility in assigning responsibilities to objects
- Allows a set of classes to behave as a whole, because events produced in one class can be sent on to other handler classes.
- IOM 2068 Past Question With Answers
- UNIT-1 BBA III Year Notes – Logistics Management (Osmania University)
Chain of Responsibility Pattern: When to Use
You should use the Chain of Responsibility pattern when:
- More than one object can handle a request, and the handler isn’t known.
- You want to issue a request to one of several objects without specifying the receiver explicitly.
- The set of objects that can handle a request should be specified dynamically.
2. Command Pattern
- The Command pattern encapsulates a request in an object, which enables you to store the command, pass the command to a method, and return the command like any other object.
Command Pattern: Diagram
Command Pattern : Participants
- Command – declares an interface for executing an operation;
- ConcreteCommand – extends the Command interface, implementing the Execute method by invoking the corresponding operations on Receiver. It defines a link between the Receiver and the action.
- Client – creates a ConcreteCommand object and sets its receiver;
- Invoker – asks the command to carry out the request;
- Receiver – knows how to perform the operations;
Command Pattern: Benefits & When to Use
- It separates the object that invokes the operation from the one that knows how to perform it.
- It’s easy to add new commands, because you don’t have to change existing classes.
When to Use :
- You want to parameterize objects by an action to perform.
- You specify, queue, and execute requests at different times.
- You must support undo, logging, or transactions.
3. Interpreter Pattern
- The Interpreter pattern interprets a language to define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.
- Map a domain to a language, the language to a grammar, and the grammar to a hierarchical object-oriented design.
Interpreter Pattern: Diagram
Interpreter Pattern: Benefits & When to Use
The following lists the benefits of using the Interpreter pattern:
- It’s easy to change and extend the grammar.
- Implementing the grammar is easy.
You should use the Interpreter pattern when:
- The grammar of the language is simple.
- Efficiency is not a critical concern.
4. Iterator Pattern
- The Iterator pattern provides a consistent way to sequentially access items in a collection that is independent of and separate from the underlying collection.
- Take the responsibility of accessing and passing through the objects of the collection and put it in the iterator object.
- The iterator object will maintain the state of the iteration, keeping track of the current item and having a way of identifying what elements are next to be iterated.
Iterator Pattern: Diagram
Iterator Pattern: Benefits & When to Use
The following lists the benefits of using the Iterator pattern:
- Supports variations in the traversal of a collection
- Simplifies the interface of the collection
You should use the Iterator pattern to:
- Access collection object’s contents without exposing its internal representation
- Support multiple traversals of objects in a collection
- Provide a uniform interface for traversing different structures in a collection
- The Mediator pattern simplifies communication among objects in a system by introducing a single object that manages message distribution among other objects.
- The Mediator pattern promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently.
Mediator Pattern: Diagram
Mediator Pattern : Participants
- Mediator – defines an interface for communicating with Colleague objects.
- knows the colleague classes and keep a reference to the colleague objects.
- Implements the communication and transfer the messages between the colleague classes
- Colleague classes
- Keep a reference to its Mediator object
- Communicates with the Mediator whenever it would have otherwise communicated with another Colleague.
Mediator Pattern: Benefits
The following lists the benefits of using the Mediator pattern:
- Decouples colleagues
- Centralizes control
- The individual components become simpler and easier to deal with because they no longer need to directly pass messages to each other.
- Components are more generic because they no longer need to contain logic to deal with their communication with other components.
When to Use
- A set of objects communicate in well-defined but complex ways.
- You want to customize a behaviour that’s distributed between several objects without using subclasses.
Mediator Pattern: Related Patterns
- Facade Pattern – a simplified mediator becomes a facade pattern if the mediator is the only active class and the colleagues are passive classes.
- Adapter Pattern – the mediator patter just “mediate” the requests between the colleague classes. It is not supposed to change the messages it receives and sends; if it alters those messages then it is an Adapter pattern.
- Observer Pattern – the observer and mediator are similar patterns, solving the same problem. The main difference between them is the problem they address. The observer pattern handles the communication between observers and subjects or subject.
- GUI Libraries – Dialog Box
- Chat application – Hub and Router
- The Memento pattern preserves a “snapshot” of an object’s state so that the object can return to its original state without having to reveal its content to the rest of the world.
- The intent of this pattern is to capture the internal state of an object without violating encapsulation and thus providing a mean for restoring the object into the initial state when needed.
Momento Pattern: Diagram
Participants are : Memento –
Stores internal state of the Originator object. The state can include any number of state variables.
The Memento must have two interfaces, an interface to the caretaker. This interface must not allow any operations or any access to internal state stored by the memento and thus honors encapsulation.
The other interface is to the originator and allows the originator to access any state variables necessary to for the originator to restore the previous state.
Momento Pattern: Participants
- Originator – Creates a memento object capturing the originators internal state. Use the memento object to restore its previous state.
- Caretaker – Responsible for keeping the memento. The memento is opaque to the caretaker, and the caretaker must not operate on it.
- Command Pattern – Commands can use mementos to maintain state for undoable operations.
- Undo and restore operations in most software.
- Database transactions.
Momento Pattern: Benefits & When to Use
- Preserves encapsulation boundaries
- Simplifies the originator
When to Use
- A snapshot of an object’s state must be saved so that it can be restored to that state later.
- The Observer pattern provides a way for a component to flexibly broadcast messages to interested receivers.
- It defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.
Observer Pattern: Diagram
Observer Pattern: Participants
- Observable – interface or abstract class defining the operations for attaching and de-attaching observers to the client. In the GOF book, this class/interface is known as Subject.
- ConcreteObservable – concrete Observable class. It maintains the state of the object and when a change in the state occurs it notifies the attached Observers.
- Observer – interface or abstract class defining the operations to be used to notify this object.
- ConcreteObserverA, ConcreteObserver2 – concrete Observer implementations.
Observer Pattern: Benefits & When to Use
- Abstract coupling between subject and observer
- Support for broadcast communication
When to Use
- A change to one object requires changing the other object, and you don’t know how many objects need to change.
- An object should be able to notify other objects without making assumptions about the identity of those objects.
- Model View Controller Pattern – In MVC this pattern is used to decouple the model from the view. View represents the Observer and the model is the Observable object.
- Event management – Swing and .Net are extensively using the Observer pattern for implementing the events mechanism.
- Java EE Platform Benefits
- Study Notes for Architecture – 2
- Study Notes for Architecture – 1
- Notes of Enterprise Application Design And Development – EADD