Design Pattern with Burger

DESIGN PATTERNFACTORY

By Irwan Fathurrahman

Order Burger

prepare bake

fillingpresentation

Public Burger orderBurger(){Burger burger = new Burger();

burger.prepare();burger.bake();burger.filling();burger.presentation();

return burger;}

Our store can take and give the order.

This is the simple way for our function to take order based of strategy in previous slide

But our store just have one kind of Burger!

We have to create 4 menu!

Public Burger orderBurger(String type){Burger burger;

if(type == “cheese”){burger = new CheeseBurger();

} else if(type == “double cheese”){burger = new DoubleCheeseBurger();

} else if(type == “beef”){burger = new BeefBurger();

} else if(type == “doublebeef”){burger = new DoubleBeefBurger();

}


return burger;}

That it!Our store can take 4 kind of Burger.

- Cheese Burger- Double Cheese

Burger- Beef Burger- Double Beef

Burger

But! What about we add new burger and remove old Burger?

Public Burger orderBurger(String type){Burger burger;

if(type == “cheese”){burger = new CheeseBurger();

} else if(type == “double cheese”){burger = new DoubleCheeseBurger();

} else if(type == “beef”){burger = new BeefBurger();

} else if(type == “doublebeef”){burger = new DoubleBeefBurger();

} else if(type == “chesse&beef”){burger = new CheeseBeefBurger();

}


return burger;}

It mess our order burger method and make order burger closed modification

Public class BurgerStore{ BurgerFactory factory; Public BurgerStore(BurgerFactory factory){ this.factory = factory; }

Public Burger orderBurger(String type){ Burger burger = factory.createBurger(type); burger.prepare(); burger.bake(); burger.filling(); burger.presentation();

return burger; }}

Make simple factory that can produce one kind burger.

SOLUTION! -> simple factory

Public class BurgerFactory{

Public Burger createBurger(String type){ Burger burger;

if(type == “cheese”){

burger = new CheeseBurger(); } else if(type == “beef”){

burger = new BeefBurger(); } else if(type == “doublebeef”){

burger = new DoubleBeefBurger(); } else if(type == “chesse&beef”){

burger = new CheeseBeefBurger(); }

return burger; }}

Now, we can sell our Burgers!

Oh Look! Our store expands!Now we have 2 store, but have different menu

Back to old solution?Because our both store have different menu, we

can’t have same factory

- It can be a solution. Each store can choose their own factory.- But if other store share one factory and suddenly add their own

menu, it can be a problem later.

Add 2 factory

Public class BurgerFactoryStore1{





burger = new DoubleBeefBurger(); } else if(type == “chesse&beef”){

burger = new CheeseBeefBurger(); }

return burger; }}

Public class BurgerFactoryStore2{



burger = new CheeseBurger(); } else if(type == “doublecheese”){

burger = new DoubleCheeseBurger(); } else if(type == “beef”){


burger = new DoubleBeefBurger(); } return burger; }}

Solution?What about we make every store decide their

own menu?

Public abstract class BurgerStore{ BurgerFactory factory; Public BurgerStore(BurgerFactory factory){ this.factory = factory; }

Public Burger orderBurger(String type){ Burger burger = createBurger(type); burger.prepare(); burger.bake(); burger.filling(); burger.presentation();

return burger; }

Public abstract Burger createBurger (String type);}

We just make interface for our store, but they can decide their own

menu.

SOLUTION! -> factory method Public class Store1 extends BurgerStore{




burger = new BeefBurger(); } return burger;

}}

Public class Store2 extends BurgerStore{


if(type == “beef”){


burger = new DoubleBeefBurger(); } return burger;

}}

But we have other problem!Customer want other style of vegetable and beef

too.

Public abstract class Burger{ Beef factory; Vegetable vegetable;

Public abstract void prepare();

Public void bake(){ // some method }

Public void filling(){ // some method }

Public void presentation(){ // some method }}

One of our kind of Burger

Look our Burger

Public class ChesseBburger extends Burger{ Public void ChesseBburger(// need ingredient){

}

Public void prepare(){};

}

Public interface IngredientFactory {

Public Beef createBeef(); Public Vegetable createVegetable();}

This our ingredient creator

Need ingredient factory that create beef and vegetable

Public class IndonesianBurgerIngredientFactory {

Public Beef createBeef(){ return new SapiLadaHitam(); } Public Vegetable createVegetable(){ return new Kangkung(); }}

Public class JapaneseBurgerIngredientFactory {

Public Beef createBeef(){ return new FreshFish(); } Public Vegetable createVegetable(){ return new Nori(); }}

Public class ChesseBburger extends Burger{ IngredientFactory ingredient;

Public void ChesseBburger( IngredientFactory ingredient){ this.Ingredient = ingredient;

}

Public void prepare(){ ingredient.createBeef(); ingredient.createVegetable(); };

}

Solution! -> Abstract Factory Method

Now we can take ingredient style customer want without affecting our method in burger.

Public class Store1 extends BurgerStore{

Public Burger createBurger(String type, IngredientFactory ingredient){ Burger burger;


burger = new CheeseBurger(ingredient); } else if(type == “beef”){

burger = new BeefBurger(ingredient); } return burger;

}}

Review Simple factory is a simple way to decouple our

client from concrete class. Factory Method relies on inheritance : object

creation is delegated to subclasses which implement the factory method to create object.

Abstract factory Method relies on object composition : ocject creation is implemented in method exposed in factory interface.

Review All factory pattern promote loose coupling by

reducing the depedency on concrete class.

Concrete class is class which will be an object concrete.

Design Pattern Is a description or template for how to solve a

problem that can be used in many different situations.

Design patterns are optimized, reusable solutions to the programming problems that we encounter every day.

Design Principle Take the parts that vary and encapsulate them. So, we can can alter or extend that vary later

without affecting those that don’t.

Design Principle Code for an interface, not code for and

implementation.

Design Principle Depend upon abstraction, don’t upon concrete

class.

Technology

Design Pattern with Burger