Design Pattern with Burger

Order Burger

prepare

bake

presentation

filling

Public Burger orderBurger(){
Burger burger = new Burger();
burger.prepare();
burger.bake();
burger.filling();
burger.presentation();

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

return burger;

}

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();
}

That it!
Our store can take 4
kind of Burger.
- Cheese Burger
- Double Cheese
Burger
- Beef Burger
- Double Beef Burger

burger.prepare();
burger.bake();
burger.filling();
return burger;
}

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

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

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

burger.prepare();
burger.bake();
burger.filling();
return burger;
}

SOLUTION! -> simple factory
Make simple factory that can
produce one kind burger.

Public class BurgerStore{
BurgerFactory factory;
Public BurgerStore(BurgerFactory factory){
this.factory = factory;
}
Burger burger = factory.createBurger(type);
burger.prepare();
burger.bake();
burger.filling();

Public class BurgerFactory{
return burger;
Public Burger createBurger(String type){
Burger burger;
}
return burger;

}
}

}

}

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

Add 2 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.

Public class BurgerFactoryStore1{

Public class BurgerFactoryStore2{

Burger burger;

Burger burger;

}

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

return burger;

}
}

}

}

Solution?
What about we make every store decide their own
menu?

SOLUTION! -> factory method

Public class Store1 extends BurgerStore{
Burger burger;

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

Public abstract class BurgerStore{
BurgerFactory factory;

}
return burger;
}
}

Public BurgerStore(BurgerFactory factory){
this.factory = factory;
}
Burger burger = createBurger(type);

Burger burger;

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

if(type == “beef”){
}
return burger;

return burger;
}
Public abstract Burger createBurger
(String type);
}

}
}

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

Look our Burger

One of our kind of Burger

Public abstract class Burger{
Beef factory;
Vegetable vegetable;
Public abstract void prepare();
Public void bake(){
// some method
}
Public void filling(){
// some method
}

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

Public void presentation(){
// some method
}

}
}
Public void prepare(){};
}

This our ingredient creator
Public interface IngredientFactory {

Need ingredient factory that create
beef and vegetable

Public class IndonesianBurgerIngredientFactory {

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

Public class JapaneseBurgerIngredientFactory {

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

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

Solution! -> Abstract Factory Method
Now we can take ingredient style
customer want without affecting
our method in burger.

Public class ChesseBburger extends Burger{
IngredientFactory ingredient;
Public void ChesseBburger(
IngredientFactory ingredient){
this.Ingredient = ingredient;
}
Public void prepare(){
ingredient.createBeef();
ingredient.createVegetable();
};

Public Burger createBurger(String type,
IngredientFactory ingredient){
Burger burger;
burger = new CheeseBurger(ingredient);
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.

Design Pattern with Burger

Recommended

Recommended

More Related Content

Recently uploaded

Recently uploaded (20)

Featured

Featured (20)

Design Pattern with Burger