Assignment 1

Title :
Study any two patterns and SUBMIT a design pattern specification these in a standard format along with their UML diagrams. The specification must include Problem/ Issue, Audience/ Context, Forces, Solution, Discussion/ Consequences/ Implementation, Related Patterns, Example Instances, References.

Theory:
Introduction:
Creational design patterns abstract the instantiation process.they help make a system independent of how its objects are created,composed & represented.a class creational pattern uses inheritanceto vary the class that’s intiated,where as creational pattern will delegate instantiation to another object.creational pattern become important as systems evolve to depend more on object composition than class inheritance.as that happens,emphasis shifts away from hard-coding a fixed set of behaviors toword defining a smaller set of fundamental behaviours that can be composedinto any no. of more complex onces.thus creating objects with perticular behaviour requires more than simply instantiating a class.

Design patterns

“Each pattern describes a problem which occurs over and over again in our environment, and then describes the core of the solution to that problem, in such a way that you can use this solution a million times over, without ever doing it the same way twice.”
[Christopher Alexander]

Design patterns capture the best practices of experienced object-oriented software developers.

Design patterns are solutions to general software development problems.

A pattern has four essential elements * Pattern Name * Problem * Solution * Consequences

Pattern Name: Is a handle we can use to describe a design problem, it’s solutions & consequences in a word or two. Naming a pattern immediately increases our design vocabulary. It lets us design at a higher level of abstraction.

Problem: It describes when to apply the pattern. It explains the problems and it’s context. It might describe specific design problems such as how to represent algorithms as objects. It might describe class or object structures that are symptomatic of an inflexible design.

Solution: Describes the elements that make up the design, their relationships, responsibilities and collaborations. The solution doesn’t describe a particular concrete design or implementation, because a pattern is like a template that can be applied in many different situations. Instead the pattern provides an abstract description of a design problem & how a general agreement of elements solve it.

Consequences: Are the results and trade-offs of applying the pattern. Though consequences are often unvoiced when we describe design decisions, they are critical for evaluating design alteration and for understanding the costs & benefits of applying the pattern.

Design patterns can be (roughly) grouped into three categories: * Creational patterns are ones that create objects for you, rather than having you instantiate objects directly. This gives your program more flexibility in deciding which objects need to be created for a given case.

* Structural patterns help you compose groups of objects into larger structures, such as complex user interfaces or accounting data.

* Behavioral patterns help you define the communication between objects in your system and how the flow is controlled in a complex program. The different design patterns are as follows: 1. Factory Method 2. Singleton 3. Adaptor 4. Façade 5. Proxy 6. Iterator 7. Mediator 8. Memento 9. Observer 10. Pipes and Filters

We will study two design patterns in this assignment.

1. The Factory Pattern

* Factory patterns are examples of creational patterns * Creational patterns abstract the object instantiation process. They hide how objects are created and help make the overall system independent of how its objects are created and composed. * Class creational patterns focus on the use of inheritance to decide the object to be instantiated.
Factory Method * Object creational patterns focus on the delegation of the instantiation to another object.
Abstract Factory

Intent Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

Motivation
Consider the following framework:

The createDocument() method is a factory method.

Applicability
Use the Factory Method pattern in any of the following situations: * A class can't anticipate the class of objects it must create * A class wants its subclasses to specify the objects it creates

Structure

Participants * Product
Defines the interface for the type of objects the factory method creates * ConcreteProduct
Implements the Product interface * Creator
Declares the factory method, which returns an object of type Product * ConcreteCreator
Overrides the factory method to return an instance of a ConcreteProduct

Collaborations * Creator relies on its subclasses to implement the factory method so that it returns an instance of the appropriate ConcreteProduct

So what exactly does it mean when we say that "the Factory Method Pattern lets subclasses decide which class to instantiate?"
It means that Creator class is written without knowing what actual ConcreteProduct class will be instantiated. The ConcreteProduct class which is instantiated is determined solely by which ConcreteCreator subclass is instantiated and used by the application.
It does not mean that somehow the subclass decides at runtime which ConreteProduct class to create
Clients can also use factory methods:

The factory method in this case is createManipulator()
Note that although the Client delegates the creation of a ConcreteManipulator to a ConcreteFigure object, the focus of the pattern is still on how a specific subclass of Figure creates one particular type of Manipulator. So this is still the Factory Method Pattern (a class creational pattern).

Class Diagram for Factory Pattern

Sequence Diagram for Factory Pattern

2. The Singleton Pattern In many systems, there should often only be one object instance for a given class * Print spooler * File system * Window manager
This pattern answers the question: How to design the class such that any client cannot create more than one instance of the class?
The key participants in this pattern are:
The Singleton, the class which only allows one instance to be created

Intent
Ensure a class only has one instance, and provide a global point of access to it

Motivation
Sometimes we want just a single instance of a class to exist in the system
For example, we want just one window manager Or just one factory for a family of products.
We need to have that one instance easily accessible And we want to ensure that additional instances of the class cannot be created.

Structure

Consequences * Benefits * Permits a variable number of instances * Controlled access to sole instance
As the constructor is protected, the class controls when an instance is created * Reduced name space
Eliminates the need for global variables that store single instances * Permits refinement of operations and representations
You can easily sub-class the Singleton * Permits a variable number of instances
The class is easily modified to allow n instances when n is not 1 * More flexible than class operations
This pattern eliminates the need for class (i.e. static) methods

We'll use a static method to allow clients to get a reference to the single instance and we’ll use a private constructor!

Singleton Implementation * Note that the singleton instance is only created when needed. This is called lazy instantiation.
Two instances of the singleton class could be created! * How could we prevent this? Several methods: * Make the instance() synchronized. Synchronization is expensive, however, and is really only needed the first time the unique instance is created. * Do an eager instantiation of the instance rather than a lazy instantiation.

Class Diagram for Singleton Pattern

Sequence Diagram for Singleton Pattern

Conclusion: In this assignment the study of Factory pattern and Singleton pattern is completed.