Design patterns, the big picture, Part 1: Design pattern history and classification
Understanding the concept and use of design patterns in software development
By Jeff Friesen, JavaWorld.com, 11/21/12
Page 5 of 6
- Adapter: Converts a class's interface into another interface that clients expect. An adapter lets classes work together that otherwise
couldn't due to incompatible interfaces. It does so by providing its interface to clients while using the original class interfaces
internally. Adapter is also known as the Wrapper pattern.
- Bridge: Decouples an abstraction from its implementation, which lets the two vary independently. The bridge uses encapsulation, aggregation, and can also use inheritance to separate responsibilities into different classes.
- Composite: Composes objects into tree structures that represent part-whole hierarchies. Composite lets clients treat individual objects
and compositions of objects uniformly.
- Decorator: Dynamically attaches additional responsibilities to an object while maintaining the same interface. Decorators provide a
flexible alternative to subclassing for extending functionality.
- Facade: Provides a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the
subsystem easier to use. Facades can wrap poorly-designed APIs in a single well-defined API.
- Flyweight: Uses sharing to support large numbers of similar objects efficiently. A flyweight is an object that minimizes memory use by sharing as much data as possible with other similar objects. It offers a way to
use objects in large numbers when a simple repeated representation would result in an unacceptable amount of allocated memory.
- Front controller: Provides a centralized entry point for handling requests. This pattern relates to the design of Web applications.
- Module: Implements the concept of software modules, defined by modular programming, in a programming language that does not support
or only partly supports modules.
- Proxy: Provides a surrogate or placeholder object for another object. This proxy controls access to the other object.
Behavioral patterns
Behavioral patterns focus on algorithms and the assignment of responsibilities between objects. They address object or class patterns as well
as the communication patterns between them. A behavioral class pattern uses inheritance to distribute behavior among classes. In contrast, a behavioral object pattern uses object composition.
- Blackboard: This is a generalization of the Observer pattern that supports multiple readers and writers. The Blackboard pattern communicates
information systemwide.
- Chain of responsibility: Avoids coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. This
pattern chains together receiving objects and passes a request along the chain until an object handles the request.
- Command: Uses an object to encapsulate all information needed to call a method at a later time. This information includes the method
name, the object that owns the method, and values for the method parameters. A client instantiates the command object and
provides the information required to call the method. The invoker decides when the method should be called. Finally, the receiver
is an instance of the class that contains the method's code.
- Interpreter: Given a language, defines a representation for its grammar along with an interpreter that uses the representation to interpret
sentences in the language.
- Iterator: Enables developers to access the elements of an aggregate object sequentially without exposing its underlying representation.
- Mediator: Defines an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from
referring to each other explicitly, and it lets you vary their interaction independently.
- Memento: Without violating encapsulation, captures and externalizes an object's internal state so that the object can be subsequently
restored to this state.
- Null Object: Avoids null references by providing a default object.
- Observer: Defines a one-to-many dependency between objects where a state change in one object results in all of its dependents being
notified and updated automatically. Observer is also known as the Publish-subscribe pattern.
- Servant: Defines functionality for a group of classes without defining that functionality in each of those classes. A servant is a class whose instance (or the class itself) provides methods that perform a desired service, while objects for which
(or with whom) the servant does something are passed to servant methods as parameters.
- Specification: Recombines business rules by chaining the business rules together using Boolean logic.
- State: Allows an object to alter its behavior when its internal state changes. The object will appear to change its class.
- Strategy: Defines a family of algorithms, encapsulates each one, and makes them interchangeable. Strategy lets the algorithm vary
independently from clients that use it.
- Template method: Defines the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template method lets subclasses
redefine certain steps of an algorithm without changing the algorithm's structure.
- Visitor: Represents an operation to be performed on the elements of an object structure. Visitor lets you define a new operation
without changing the classes of the elements on which it operates.
Concurrency patterns
Finally, a concurrency pattern addresses some aspect of multithreaded programming. One well-known pattern in this category is Producer-consumer, in which a producer thread stores an item in a shared buffer and a consumer thread retrieves this item. The producer thread
must not store another item in this buffer until the previous item has been consumed, and the consumer thread must not consume
a non-existent item.