DESIGN PATTERNS: Elements of Reusable Object-Oriented Software

Patterns from Design Patterns: Elements of Reusable Object-Oriented Software. The book's authors are Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides (often referred to as the Gang of Four (GoF)) with a foreword by Grady Booch.

Common searches: Creational Structural Behavioral 

= 26 items (filtered by ) /
  • Creational Patterns
    Create objects for you, rather than having you instantiate objects directly.
    • Builder
      Constructs complex objects by separating construction and representation.
      • Factory Method
        Creates objects without specifying the exact class to create.
        • Prototype
          Creates objects by cloning an existing object.
          • Singleton
            Restricts object creation for a class to only one instance.
            • Structural Patterns
              Use inheritance to compose interfaces and define ways to compose objects to obtain new functionality.
              • Adapter
                Allows classes with incompatible interfaces to work together by wrapping its own interface around that of an already existing class.
                • Bridge
                  Decouples an abstraction from its implementation so that the two can vary independently.
                  • Composite
                    Composes zero-or-more similar objects so that they can be manipulated as one object.
                    • Decorator
                      Dynamically adds/overrides behaviour in an existing method of an object.
                      • Facade
                        Provides a simplified interface to a large body of code.
                        • Flyweight
                          Reduces the cost of creating and manipulating a large number of similar objects.
                          • Proxy
                            Provides a placeholder for another object to control access, reduce cost, and reduce complexity.
                            • Behavioral Patterns
                              Concerned with communication between objects.
                              • Command
                                Creates objects which encapsulate actions and parameters.
                                • Iterator
                                  Allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
                                  • Mediator
                                    Allows loose coupling between classes by being the only class that has detailed knowledge of their methods.
                                    • Memento (Undo)
                                      Provides the ability to restore an object to its previous state (undo).
                                      • Observer
                                        A publish/subscribe pattern which allows a number of observer objects to see an event.
                                        • State
                                          Allows an object to alter its behavior when its internal state changes.
                                          • Strategy (Policy)
                                            Allows one of a family of algorithms to be selected on-the-fly at runtime.
                                            • Template Method
                                              Defines the skeleton of an algorithm as an abstract class, allowing its subclasses to provide concrete behavior.
                                              • Visitor
                                                Separates an algorithm from an object structure by moving the hierarchy of methods into one object.
                                                VisitorTemplate MethodStrategy (Policy)StateObserverMemento (Undo)MediatorIteratorInterpreterCommandChain of ResponsibilityBehavioral PatternsProxyFlyweightFacadeDecoratorCompositeBridgeAdapterStructural PatternsSingletonPrototypeFactory MethodBuilderAbstract FactoryCreational PatternsCloud Design Patterns