Design Patterns: Elements of Reusable Object-Oriented Software

Book

Thumbnail
Design Patterns: Elements of Reusable Object-Oriented Software is a software engineering book describing recurring solutions to common problems in software design. The book is divided into two parts, with the first two chapters exploring the capabilities and pitfalls of object-oriented programming, and the remaining chapters describing 23 classic software design patterns. The book includes examples in C++ and Smalltalk.

Get more Information

Authors

Patterns

Abstract Factory

Creational Pattern

An abstract factory offers the interface for creating a set of related or dependant objects without explicitly specifying their classes. The type of the created objects are determined at run-time.

Adapter

Structural Pattern

The adapter pattern is a design pattern that is used to allow two incompatible types to communicate. Where one class relies upon a specific interface that is not implemented by another class, the adapter acts as a translator between the two types.

Bridge

Structural Pattern

The bridge pattern is a design pattern that separates the abstract elements of a class from its technical implementation. This provides a cleaner implementation of real-world objects and allows the implementation details to be changed easily.

Builder

Creational Pattern

Instead of using numerous constructors, the builder pattern uses a builder object, that instantiates and initializes objects using a multiple of steps.

Chain of Responsibility

Behavioral Pattern

The chain of responsibility pattern is a design pattern that defines a linked list of handlers, each of which is able to process requests. When a request is submitted to the chain, it is passed to the first handler in the list that is able to process it.

Command

Behavioral Pattern

A command object encapsulates a request as an object. This object is sent to a receiver which executes the command. The advantage of this technique is that the requests can be queued, logged or implemented to support undo/redo.

Composite

Structural Pattern

The composite pattern describes a way to create tree structures using objects and object groups. The clients can access and use individual objects and compositions in the same manner.

Decorator

Structural Pattern

A decorator allows to add behavior to an individual object, either statically or dynamically, without affecting the behavior of other objects from the same class.

Facade

Structural Pattern

The facade pattern is used to define a simplified interface to a more complex subsystem.

Factory Method

Creational Pattern

An object with methods to create objects without specifying the exact class that will be created. Depending on the concrete factory implementation objects with different classes are created.

Flyweight

Structural Pattern

The flyweight pattern is used to reduce the memory and resource usage for complex models containing many hundreds, thousands or hundreds of thousands of similar objects.

Interpreter

Behavioral Pattern

The interpreter pattern is used to define the grammar for instructions that form part of a language or notation, whilst allowing the grammar to be easily extended.

Iterator

Behavioral Pattern

An iterator provides the interface to traverse a container's elements. The implementation is hidden so that the client does not need to understand the traversing algorithm.

Mediator

Behavioral Pattern

The mediator pattern is used to reduce coupling between classes that communicate with each other. Instead of classes communicating directly, and thus requiring knowledge of their implementation, the classes send messages via a mediator object.

Memento

Behavioral Pattern

The memento pattern is used to capture the current state of an object and store it in such a manner that it can be restored at a later time without breaking the rules of encapsulation.

Observer

Behavioral Pattern

The observer pattern is used to allow an object to publish changes to its state. Other objects subscribe to be immediately notified of any changes.

Prototype

Creational Pattern

The prototype pattern is used to instantiate a new object by copying all of the properties of an existing object, creating an independent clone. This practise is particularly useful when the construction of a new object is inefficient.

Proxy

Structural Pattern

The proxy pattern is used to provide a surrogate or placeholder object, which references an underlying object. The proxy provides the same public interface as the underlying subject class, adding a level of indirection by accepting requests from a client object and passing these to the real subject object as necessary.

Singleton

Creational Pattern

A singleton is an object whose class can only have one instance. A singleton class ensures that only one instance of the class can be created. The pattern is often called an anti-pattern because it may lead to high coupling of components.

State

Behavioral Pattern

The state pattern is used to alter the behaviour of an object as its internal state changes. The pattern allows the class for an object to apparently change at run-time.