Simple Factory (idiom)

code로 이해하자.

Restaurant : client

public class Restaurant { //client
    SimpleBurgerFactory factory;

    public Restaurant(SimpleBurgerFactory factory) {
        this.factory = factory;
    }

    public Burger orderBurger(String type) {
        Burger burger = factory.createBurger(type);

        burger.prepare();
        burger.cook();

        return burger;
    }

}

SimpleBurgerFactory : factory

public class SimpleBurgerFactory {

    public Burger createBurger(String type) {
        Burger burger = null;

        if(type.equals("beef")) {
            burger = new BeefBurger();
        } else if (type.equals("veggie")) {
            burger = new VeggieBurger();
        }

        return burger;
    }
}

Burger : Product

public abstract class Burger {
    public abstract void prepare();

    public abstract void cook();
}

VeggieBurger : Concrete Product

public class VeggieBurger extends Burger {
    public void prepare() {
        System.out.println("Veggie preparing");
    }

    public void cook() {
        System.out.println("Veggie cooking");
    }
}

BeefBurger : Concrete Product

public class BeefBurger extends Burger {
    public void prepare() {
        System.out.println("BeefBurger preparing");
    }

    public void cook() {
        System.out.println("BeefBurger cooking");
    }
}

Factory Method Pattern

creation design pattern

위 UML로 구현하는게 결론인데 코드 예시로 기억하자.

Restaurant : creator

public abstract class Restaurant {

//    public Restaurant(SimpleBurgerFactory factory) {
//        this.factory = factory;
//    }
    // 더이상 다른 객체에 의존할 필요가 없어짐!

    public Burger orderBurger() {
        Burger burger = createBurger();
        burger.prepare();
        burger.cook();
        return burger;
    }

    public abstract Burger createBurger(); //이게 Factory Method!!!!
}

BeefBurgerRestaurant : Concrete Creator

public class BeefBurgerRestaurant extends Restaurant {

    @Override
    public Burger createBurger() {
        return new BeefBurger();
    }
}

VeggieBurgerRestaurant : Concrete Creator

public class VeggieBurgerRestaurant extends Restaurant {

    @Override
    public Burger createBurger() {
        return new VeggieBurger();
    }
}

Burger : Product

public interface Burger {
    public abstract void prepare();

    public abstract void cook();
}

BeefBurger : Concrete Product

public class BeefBurger implements Burger {
    public void prepare() {
        System.out.println("BeefBurger preparing");
    }

    public void cook() {
        System.out.println("BeefBurger cooking");
    }
}

VeggieBurger : concrete product

public class VeggieBurger implements Burger {
    public void prepare() {
        System.out.println("Veggie preparing");
    }

    public void cook() {
        System.out.println("Veggie cooking");
    }
}

main

import java.util.Scanner;

public class RestaurantMain {
    public static void main(String[] args) {
        Restaurant beefRestaurant = new BeefBurgerRestaurant();
        Restaurant veggieRestaurant = new VeggieBurgerRestaurant();

        Burger burger1 = beefRestaurant.orderBurger();
        Burger burger2= veggieRestaurant.orderBurger();

    }
}

Factory Method는 반드시 Concrete Product를 반환해야 한다.

when and why?

product construction code와 product application code를 분리

-> 새 product를 다른 코드의 수정없이 사용가능

특정 객체의 정확한 type과 dependency를 모를 때