abstract factory abstract factory using factory method

Abstract Factory

Abstract Factory using Factory Method

Factory Method

PizzaStoreorderPizza()

SimplePizzaFactorycreatePizza()

Pizzaprepare()bake()cut()box()

CheesePizza

VeggiePizza

ClamPizza

ClamPizza

2

Creating multiple factories

PizzaStore

NYPizzaFactory

ChicagoPizzaFactory

3

Creating Multiple Factories To demonstrate the factory method pattern, the

pizza store example evolves To include the notion of different franchises That exist in different parts of the country (California,

New York, Chicago) Each franchise will need its own factory to create

pizzas that match the tastes of the locals However, we want to retain the creation process that

has made PizzaStore such a great success The Factory Method Design Pattern allows you to

do this by placing abstract, “code to an interface” code in a

superclass placing object creation code in a subclass PizzaStore becomes an abstract class with an abstract

createPizza() method We then create subclasses that override

CreatePizza() for each region4

Changes in PizzaStore

public abstract class PizzaStore

{

Pizza pizza = null;

public abstract Pizza CreatePizza(String type);

public void OrderPizza(String type)

{

pizza = CreatePizza(type);

pizza.Prepare();

pizza.Bake();

pizza.Cut();

pizza.Box();

}//Method of Ordering a Pizza

}5

Concrete Pizza Store Classespublic class NYPizzaStore :

PizzaStore

{

public override Pizza CreatePizza(string type)

{

if (type.Equals("cheese"))

{ return new NYCheesePizza(); }

else if (type.Equals("pepperoni"))

{return new NYPepperoniPizza();}

return null;

}

}

public class ChicagoPizzaStore : PizzaStore {

public override Pizza CreatePizza(String type)

{

if(type.Equals("cheese")) { return new ChicagoCheesePizza();}

else if(type.Equals("pepperoni")) { return new ChicagoPepperoniPizza();}

return null; } }

6

Calling Program

7

class Program { static void Main(string[] args) { //Calling the NY Pizza Store to Order our

Cheese Pizza PizzaStore nypizzastore = new

NYPizzaStore(); nypizzastore.OrderPizza("cheese");

Console.ReadLine(); } }

Allowing the subclasses to decide

PizzaStorecreatePizza()orderPizza()

NYStylePizzaStorecreatePizza()

ChicagoStylePizzaStorecreatePizza()

A factory method CreatePizza() handles object creation and encapsulates it in the subclass. This decouples the client code in the super class from the object creation that happens in the subclass.

8

Pizza Store Franchises

PizzaStorecreatePizza()orderPizza()

NYStylePizzaStorecreatePizza()

ChicagoStylePizzaStorecreatePizza()

Pizza

NYStyleCheesePizzaNYStyleCheesePizza

NYStyleCheesePizzaNYStyleCheesePizza

ChStyleCheesePizzaChStyleCheesePizza

ChStyleCheesePizzaChStyleCheesePizza

Creator Classes

Product Classes

9

Looking at object dependencies

PizzaStore

NyStyleCheezePizza

NyStyleCheezePizza

NyStyleCheezePizza

NyStyleCheesePizza

ChicagoCheezePizza

ChicagoCheezePizza

ChicagoCheezePizza

ChicagoCheesePizza

Because the Pizza Store depends on the concrete implementations any change in concrete classes may change the Pizza Store class

Before Applying Factory Method

10

Design PrincipleDependency Inversion Principle

Depend upon abstractions. Do not depend upon concrete classes.

“High level modules should not depend upon low level modules. Both should depend upon abstractions. Abstractions should not depend upon details. Details should depend upon abstractions.”

11

Applying the principle

PizzaStore

NyStyleCheezePizza

NyStyleCheezePizza

NyStyleCheezePizza

NyStyleCheesePizza

ChicagoCheezePizza

ChicagoCheezePizza

ChicagoCheezePizza

ChicagoCheesePizza

Pizza

Pizza is an abstract class

12

Some guidelines to help with the principle Try and avoid having variables that refer to a

concrete class Instead of using new use a factory to achieve this

Try and avoid deriving from a concrete class Derive from an abstract class

Try and avoid overriding an implemented method Could be done if deriving from an abstract class

13

Moving On… The factory method approach to the pizza

store is a big success allowing our company to create multiple franchises across the country quickly and easily

But, bad news, we have learned that some of the franchises while following our procedures (the abstract code

in PizzaStore forces them to) are skimping on ingredients in order to lower costs

and increase margins So what can be done?

14

Abstract Factory to the Rescue! We will alter our design such that a factory is

used to supply the ingredients that are needed during the pizza creation process

Since different regions use different types of ingredients, we’ll create region-specific subclasses of the ingredient factory to ensure that the right ingredients are used

But, even with region-specific requirements, since we are supplying the factories, we’ll make sure that ingredients that meet our quality standards are used by all franchises

But first let us look at what Abstract Factory Pattern is?

15

Intent

Provide an interface for creating families of related or dependent objects without specifying their concrete classes

A.k.a Kit The Abstract Factory pattern is very similar

to the Factory Method pattern One difference between the two is that

with the Abstract Factory pattern, a class delegates the responsibility of object instantiation to another object via composition

Whereas the Factory Method pattern uses inheritance and relies on a subclass to handle the desired object instantiation

16

Motivation Consider a user interface that supports multiple look

and feel standards Different look and feel standards define different

appearances and behaviors of user interface widgets like buttons, windows etc.

The application should not hard code its widgets to a particular look and feel

Using objects of individual look and feel standards makes it hard to change the look and feel later.

This problem can be solved by Abstract Widget Factory class, and abstract classes for each kind of widget.

Concrete classes implement the widgets for a particular look and feel standard

Also enforces dependencies between the concrete classes. 17

Motivation (Cont’d)

Scrollbar*

CreateScrollBar()CreateWindow()

WidgetFactory*


MotifWidgetFactory


PMWidgetFactory

Client

Window*

MotifWindow

MotifScrollbarPMScrollbar

PMWindow

18

ApplicabilityUse the Abstract Factory pattern when A system should be independent of how its

products are created, composed and represented

A system should be configured with one of multiple families of products

A family of related product objects is designed to be used together, and you need to enforce this constraint.

You want to provide a class library of products, and you want to reveal just their interfaces, not their implementations.

19

Structure

20

Participants Abstract Factory (WidgetFactory)

Declares an interface for operations that create abstract product objects

Concrete Factory (MotifWidgetFactory, PMWidgetFactory) Implements the operations to create concrete product

objects Abstract Product (Window, Scrollbar, Button)

Declares an interface for a type of product object Concrete Product (MotifWindow, MotifScrollbar)

Defines a product to be created by the corresponding concrete factory.

Implements the AbstractProduct interface. Client

uses only interfaces declared by AbstractFactory and AbstractProduct classes.

21

Collaborations

Normally a single instance of a ConcreteFactory class is created at run-time. (This is an example of the Singleton Pattern.) This concrete factory creates product objects having a particular implementation. To create different product objects, clients should use a different concrete factory.

AbstractFactory defers creation of product objects to its ConcreteFactory

22

Consequences Isolates concrete classes

Factory encapsulates the responsibility & process of creating product objects

Makes exchanging product families easy The class of concrete factory appears only once in

the application - that is , where it’s instantiated Promotes consistency among products

Enforces, that products from one family are used together at one time

Supporting new kinds of products is difficult AbstractFactory interface fixes the set of

products that can be created Involves changing AbstractFactory interface

and all its subclasses.23

Implementation Factories can be implemented as singletons Creating the products

Use Factory Method pattern declare FactoryMethod for each kind of

product in AbstractFactory override FactoryMethod in ConcreteFactory

Use Prototype pattern for ConcreteFactory if many product families are possible initialize the concrete factory with a

prototypical instance of each product in the family

concrete factory will create a new product by cloning the prototype

no need for a new concrete factory class for each new family24

Extending the factory pattern… Now we Expand the Pizza store example How are you going to ensure that each franchise

uses quality ingredients We are going to build factory of ingredients which

is going to produce them and ship them to the franchises.

How do we deal with families of ingredients? Chicago: ThickCrust Dough,PlumTomato Sauce,Raggiano

Cheese and Dakin Pepperoni New York: ThinCrust Dough,Mariana Sauce,Mozzarella

Cheese and Sliced Pepperoni Basically, we have got same product families

(Dough, Sauce, Cheese, Pepperoni) but different implementations based on region.25

Building the ingredient factories Lets start by defining interface that is going to

create all our ingredients

public interface PizzaIngredientsFactory { Dough CreateDough(); Sauce CreateSauce(); Cheese CreateCheese(); Pepperoni CreatePepperoni(); }

26

Building Individual Ingredient Interfaces Defining interfaces for individual ingredient

/* Defining Interfaces for our Ingredients like * Dough,Sauce,Cheese,Pepperoni */ public interface Dough{string toString();} public interface Sauce{string toString();} public interface Cheese{string toString();} public interface Pepperoni{string toString();}

27

Building NY ingredient factorypublic class NYPizzaIngredientsFactory : PizzaIngredientsFactory{

public NYPizzaIngredientsFactory() { }

public Dough CreateDough() {

return new ThinCrustDough();

}

public Sauce CreateSauce() {

return new MarianaSauce();

}

public Cheese CreateCheese(){

return new MozzarellaCheese();

}

public Pepperoni CreatePepperoni(){

return new SlicedPepperoni();

}

}

28

Building Chicago ingredient factory

29

public class ChicagoPizzaIngredientsFactory : PizzaIngredientsFactory {

public ChicagoPizzaIngredientsFactory() { }

public Dough CreateDough() {

return new ThickCrustDough();

}

public Sauce CreateSauce() {

return new PlumTomatoSauce();

}

public Cheese CreateCheese() {

return new RaggianoCheese();

}

public Pepperoni CreatePepperoni() {

return new DakinPepperoni();

}

}

Concrete Individual Ingredient Classespublic class ThickCrustDough : Dough

{

public String toString()

{return "ThickCrust style extra thick crust dough";}

}

public class ThinCrustDough : Dough{


{ return "Thin crust dough"; }

}

public class PlumTomatoSauce : Sauce{


{ return "PlumTomato Sauce"; }

}

public class MarianaSauce : Sauce{


{ return "Mariana Sauce"; }}

public class MozzarellaCheese : Cheese{


{ return "Mozzarella Cheese"; }

}

public class RaggianoCheese : Cheese{


{ return "Raggiano Cheese"; }

}

public class SlicedPepperoni : Pepperoni{


{ return "Sliced Pepperoni"; }

}

public class DakinPepperoni : Pepperoni{


{ return "Dakin Pepperoni"; }}

30

Reworking the pizzas (abstract pizza class)

public abstract class Pizza {

protected String name;

protected Dough dough;

protected Sauce sauce;

protected Cheese cheese;

protected Pepperoni pepperoni;

public Pizza() { }

//Declarations of Pizza Funtions

public abstract void Prepare();

public abstract void Bake();

public abstract void Cut();

public abstract void Box();

}

31

Reworking the Pizza Concrete classes

32

When we wrote the Factory method we had four concrete classes of Pizza NYCheesePizza ChicagoCheesePizza NYPepperoniPizza ChicagoPepperoniPizza

Now we don’t need these four classes and the Factory is going to handle the type of pizza for us we would only have two classes now CheesePizza PepperoniPizza

CheesePizza Class

33

public class CheesePizza : Pizza {

PizzaIngredientsFactory ingredientsfactory;

public CheesePizza(PizzaIngredientsFactory ingredientsfactory){

this.ingredientsfactory = ingredientsfactory;

}

public override void Prepare(){

dough = ingredientsfactory.CreateDough();

sauce = ingredientsfactory.CreateSauce();

cheese = ingredientsfactory.CreateCheese();

pepperoni = ingredientsfactory.CreatePepperoni();

Console.WriteLine("Pizza has been Prepared using" + dough.toString() + sauce.toString() + cheese.toString() + pepperoni.toString());

}

public override void Bake() { Console.WriteLine("Baking CHEESE PIZZA"); }

public override void Cut() { Console.WriteLine("Cutting CHEESE PIZZA"); }

public override void Box() { Console.WriteLine("Boxing CHEESE PIZZA"); } }

Reworking the PizzaStore Concrete Classes

34

We will work on the individual Pizza Stores like NY Pizza Store to update them about the relevant ingredients factory

public class NYPizzaStore : PizzaStore {

protected override Pizza CreatePizza(string type){

Pizza pizza = null;

PizzaIngredientsFactory ingredientsFactory = new NYPizzaIngredientsFactory();

if (type.Equals("Cheese"))

{ pizza = new CheesePizza(ingredientsFactory); }

else if (type.Equals("Pepperoni"))

{ pizza = new PepperoniPizza(ingredientsFactory); }

return pizza;

}

Our Calling Program

class Program { static void Main(string[] args) { NYPizzaStore nypizzastore = new

NYPizzaStore(); nypizzastore.OrderPizza("Pepperoni"); Console.ReadLine(); } }

35

Summary: What did we just do?

36

We created an ingredient factory interface to allow for the creation of a family of ingredients for a particular pizza

This abstract factory gives us an interface for creating a family of products The factory interface decouples the client code from

the actual factory implementations that produce context-specific sets of products

Our client code (PizzaStore) can then pick the factory appropriate to its region, plug it in, and get the correct style of pizza (Factory Method) with the correct set of ingredients (Abstract Factory)

ProductA1

Abstract Factory Pattern example

<<Interface>>PizzaIngFactoryCreateDough()

CreateCheese()

ConcreteFactory1

CreateProductA()CreateProductB()

ChicPizzaIngFctry

CreateDough()CreateCheese()

Pizza

<<Interface>>Dough

ThinCrust

<<Interface>>Cheese

NYPizzaIngFctry

CreateDougn()CreateCheese()

Reggiano

ThickCrust

Mozzarella

37

Factory Method used inside Abstract Factory

38

The job of an Abstract Factory is to define an interface for a set of products

Each method in that interface is responsible for creating a concrete product

These methods are normally factory methods, in other words factory methods are a natural way to implement the product methods in the abstract factories

abstract factory abstract factory using factory method

Documents