The 23 gof design patterns in java ,the summary
- 1. GOF Design Patterns, The summary by Achraf SFAXI IS System Architect Consultant SUN Certified Professional August 2006 The creational one’s specialize in abstracting the instation process. They help in isolating how objects are created, composed and represented from the rest of the system. They are five patterns defined in this category: Abstract Factory, Builder, Factory Method, Prototype, Singleton. The Abstract Factory The Abstract Factory provides an interface for creating families of related or dependent objects without specifying their concrete classes. When to use it ? - The system should be independent of how its products are created, composed and represented - A family of related product objects is designed to be used togetheran and we need to enforce this constraint. - We need to provide a class library of products and we want to reveal just their interfaces, not their implementations The Builder The goal of the Builder design pattern is to separate the construction of a complex object from its representations. When to use it ? - The algorithm for creating a complex object should be independent of the parts that make up the object and who they are assembled. - The construction process must allow different representations for the constructed object. achraf.sfaxi.perso.sfr.fr 1
- 2. The Factory Method The Factory Method defines an interface for creating an object but lets subclasses decide which class to instanciate. Factory method lets a class defer instantiation to subclasses. When to use it ? - A class cannot anticipate the class of objects it must create. A class wants its subclasses to specify the objects it creates. The Prototype The prototype specifies the kinds of objects to create using a prototypical instance and creates new objects by copying this prototype. When we use it ? - The classes to instanciate are specified at runtime, for example, by dynamic loading. - We have to avoid building a class hierarchy of factories that parallels the class hierarchy of products. - Instances of a class can have only a few different combinations of state The Singleton The singleton ensures that a class has only one instance and provides a global point of access to that class. When to use it ? - The must be exactly one instance of a class and it must be accessible to clients from a well-known access point. The Behavioral one’s Behavioral patterns are concerned with algorithms and the assignement of responsibilities to objects. They document the patterns of objects as well as the patterns of communication between them. They are eleven patterns defined in this category : Chain of responsibility, Command, Interpreter, Iterator, Mediator, Memento, Observer, State, strategy, Template Method and Visitor. The Chain of responsibility Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chains the receiving objects and passes the request along the chain until an object handles it Reduced coupling Added flexibility in assigning responsibilities to objects. When to use it ? More than one object can handle a request, and the handler isn’t known. - The set of objects that can handle a request should be specified dynamically The Command The Comand encapsulates a request as an object. When to use it ? achraf.sfaxi.perso.sfr.fr 2
- 3. - When it is necessary to issue requests to objects without knowing anything about the operation being requested or the receiver of the request. - You specify queue and execute requests at different times. - You must support undo, logging or transactions The Interpreter Given a language, defines a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language. When to use it ? - The grammar of the language is simple - Efficiency is not a critical concern The Iterator The Iterator provides a way to access the elements of an aggregate object sequentially without exposing its underlying representation. When to use it ? - We want to access a collection object’s contents without exposing its internal representation. - Provide a uniform interface for traversing different structures in a collection. The Mediator The Mediator defines an object that encapsulates how a set of objects interacts. In a complex object structure where they are many connection between objects, every object must has knowledge of the other. We can avoid this by defining a separate mediator object that is responsible for controlling and coordinating the interaction of a group of objects (like a router for a network hosts). When to use it ? - A set of objects of objects communicates in well-defined but complex ways. - Reusing an object is difficult because it refers to and communicates with many objects The Memento Violating encapsulation, the Memento pattern captures and externaliszes an object’s internal state so that the object can be restored to this state later. A Memento is an object that stores a snapshot of the internal state of another object (the Momento’s originator). When to use it ? - A snapshot of an object’s state must be saved so it can be restored to that state later - A direct interface to obtain the state would expose implementation details and break the object’s encapsulation The Observer The Observer defines a one-to-many dependency between objects so that when one object changes state, all its dependents are automatically notified and updated. When to use it ? achraf.sfaxi.perso.sfr.fr 3
- 4. - A need to support the broadcast communication. - A change to one object requires changing others and we don’t know how many objects need to be changed. - An object should be able to notify other objects without making assumptions about who these objects are. The State Allows an object to alter its behavior when its internal state changes. The object will appear to change its class. When to use it ? - An object’s behavior depends on its state and it must change its behavior at runtime depending on that state. - Operations have large, multipart conditional statements that depend on the object’s state. The Strategy The strategy pattern defines a group of classes that represent a set of possible behaviors. The functionality differs depending on the strategy (algorithm) chosen When to use it ? - Many related classes differ only in their behavior - We need different variants of an algorithm The template Method The Template Method defines the skeleton of an algorithm in an operation defining some steps to subclasses. The Template Method pattern lets subclasses redefine certain steps of an algorithm without changing the algorithm’s structure. A template method defines an algorithm in terms of abstract operations that subclasses override to provide concrete behavior. When to use it ? - to implement the invariant parts of an algorithm once and leave it up to subclasses to implement the behavior that can vary The Visitor The Visitor pattern provides a maintainable, easy way to represent an oeration to be performed on the elements of an object structure. New operations can be defined without changing the classes of the elements on which it operates. When to use it ? - when we need to make adding new operations easy. - when the classes defining the object structure rarely change, but we often want to define new operations over thje structure. The Structural Patterns The Structural patterns are concerned with how classes and objects are composed to form larger structures. achraf.sfaxi.perso.sfr.fr 4
- 5. Seven patterns are defined in this category : Adapter, Bridge, Composite, Decorator, Façade, Flyweight and Proxy. The Adapter The Adapter design pattern defines an intermediary between two classes, converting the interface of one class so it can be used with the other. This enables classes with incompatible interfaces to work together. Let us say that it adapts a class to work with another one by making the two-classes interfaces compatible. When to use it ? - when we need to allow one or more incompatible objects to communicate and interact - when we need to improve reusability of older functionality The Bridge Decouples an abstraction from its implementation, so the two can vary independently. When to use it ? - When we need to avoid a permanent binding between an abstraction and its implementation (decouple interface and implementation) - When want to have both abstractions and their implementations extensible using subclasses. The Composite Composite pattern combines objects into tree structures to represent either the whole hierarchy or a part of the hierarchy. This recursive composition allows clients to treat individual objects and compositions of objects uniformly. When to use it ? - when we want to represent part-whole hierarchies of objects - when we want clients to be able to ignore the difference between compositions of objects and individual objects. The Decorator It attaches additional responsibilities to an object dynamically. Decorators provide a flexible alternative to subclassing for extending functionality. When to use it ? - When we want to add responsibilities ton individual objects dynamically and transparently, that is, without affecting other objects - When we want to add responsibilities that can be withdraw later - When extension by subclassing is impractical The Facade Provide a unified interface to a set of interfaces in a subsystem. Façade defines a hieigher level interface that makes the subsystem easier to use (because we only have to deal with one interface to communicate with the subsystem). When we use it ? - we want to provide a simple interface to a complex subsystem achraf.sfaxi.perso.sfr.fr 5
- 6. - There are many dependencies between clients and the implementation classes of an abstraction. The Flyweight It uses sharing to support a large number of fine-grained objects efficiently. The flyweight pattern uses a shared flyweight object that can be used in multiple contexts simultaneously. The flyweight has a shareable intrinsic state extrinsic state consisting of information independent of the flyweight’s context and a non shareable flyweight’s context. Client objects are responsible for passing extrinsic state to the flyweight when it needs it. When to use it ? - When an application uses a large number of objects. - When storage cost high because of the high number of objects - When most of the objects state can be made extrinsic - When many groups of objects may be replaced by relatively few shared objects, once extrinsic state is removed. - The benefits of using the flyweight design pattern are, essentially, reducing the number of objects to handle and reducing the memory and storage requirements The Proxy Provides a surrogate or placeholder for another object to control access to it. When to use it ? - Whenever there is a need for a more versatile or sophisticated reference to an object than a simple pointer. If you appreciate this document make a donation to a worldwide children association or organization. I suggest the SOS association. This document has been downloaded from the http://achraf.sfaxi.perso.sfr.fr space ; you can use and broadcast it for non lucrative purposes. Further information are available upon request. Si vous appréciez ce document faites un don pour le compte d’une association ou une organisation qui s’occupe des enfants. Je recommande l’association SOS. Ce document est disponible sur http://achraf.sfaxi.perso.sfr; son utilisation ainsi que sa propagation pour des fins non lucratives sont gratuite achraf.sfaxi.perso.sfr.fr 6