미친듯이 즐겨보자..

Prototype Pattern

 
public interface Product extends Cloneable {
	public abstract void use(String s);
	public abstract Product createClone();
}

public class MessageBox implements Product {
	private char decochar;
	
	public MessageBox(char decochar) {
		this.decochar = decochar;
	}	
	
	public void use(String s) {
		int length = s.getBytes().length;
		for (int i = 0; i < length + 4; i++) {
			System.out.print(decochar);
		}
		System.out.println("");
		System.out.println(decochar + " " + s + " " + decochar);
		for (int i = 0; i < length + 4; i++) {
			System.out.print(decochar);
		}
		System.out.println(" ");
	}

	public Product createClone() {
		Product p = null;
		try {
			p = (Product)clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return p;
	}
}

public class Manager {
	private HashMap showcase = new HashMap();
	
	public void register(String name, Product proto) {
		showcase.put(name, proto);
	}
	
	public Product create(String protoname) {
		Product p = (Product)showcase.get(protoname);
		return p.createClone();
	}
}

public class Main {
	public static void main(String[] args) {
		Manager manager = new Manager();
		MessageBox mbox = new MessageBox('*');
		MessageBox sbox = new MessageBox('/');
		manager.register("strong message", mbox);
		manager.register("slash box", sbox);
		
		Product p1 = manager.create("strong message");
		p1.use("Hello world");
		Product p2 = manager.create("slash box");
		p2.use("Hello world");
	}
}

정의
메소드에서 알고리즘의 골격을 정의합니다. 알고리즘의 여러 단계 중 일부는 서브클래스에서 구현할 수 있습니다. 템플릿 메소드를 이용하면 알고리즘의 구조는 그대로 유지하면서 서브클래스에서 특정 단계를 재정의할 수 있습니다.

간단하게 말하자면 알고리즘의 틀을 만들기 위한 것입니다. 일련의 단계들로 알고리즘을 정의한 메소드 입니다. 여러 단계 가운데 하나 이상이 추상 메소드로 정의되며, 그 추상 메소드는 서브클래스에서 구현됩니다.

 
abstract class AbstractClass {
	final void templateMethod() {
		primitiveOperation1();
		primitiveOperation2();
		if (hook()) {
			concreteOperation();
		}
	}
	
	// 알고리즘의 일부를 구상 서브 클래스에서 구현한다.
	abstract void primitiveOperation1();
	abstract void primitiveOperation2();
	
	/**
	 *  기본적으로 아무것도 하지 않는 구상 메소드를 정의할 수도 있습니다.
	 *  이런 메소드는 "후크(hook)"라고 부릅니다. 
	 *  서브클래스에서 오버라이드 할 수도 있지만 반드시 그래야 하는건 아니죠.
	 *  서브 클래스에서 오버라이드를 해서 알고리즘의 일부를 변경 할 수 있습니다.
	 */
	boolean hook() {
		return true;
	}

	void concreteOperation() {
		// TO DO
	}	
}

어댑터 패턴(Adapter Pattern)

정의
한 클래스의 인터페이스를 클라이언트에서 사용하고자 하는 다른 인터페이스로 변환합니다. 어댑터를 이용하면 인터페이스 호환성 문제 때문에 같이 쓸 수 없는 클래스들을 연결해서 쓸 수 있습니다.

// Target Interface
public interface Duck {
	public void quack();
	public void fly();
}

public class DuckAdapter implements Turkey {
	Duck duck;	
	public DuckAdapter(Duck duck) {
		this.duck = duck;
	}
	public void gobble() {
		duck.quack();
	}
	public void fly() {
		duck.fly();
	}
}
// Adaptee Interface
public interface Turkey {
	public void gobble();
	public void fly();
}

public class WildTurky implements Turkey {
	public void gobble() {
		System.out.println("Gobble gobble");
	}
	public void fly() {
		System.out.println("I'm flying a short distnace");
	}
}
// Adapter에서는 Target Interface를 구현하고, Adapter는 Adaptee Interface로 구성되어 있습니다.
// 모든 요청은 Adaptee 에게 위임 됩니다. 
public class TurkeyAdapter implements Duck {
	Turkey turkey;
	
	public TurkeyAdapter(Turkey turkey) {
		this.turkey = turkey;
	}
	public void quack() {
		turkey.gobble();
	}
	public void fly() {
		for (int i = 0; i < 5; i++) {
			turkey.fly();
		}
	}
}
// Client 에서는 target Interface 만 볼 수 있습니다.
public class Main {
	public static void main(String[] args) {
		MallardDuck duck = new MallardDuck();
		
		WildTurky turkey = new WildTurky();
		Duck turkeyAdapter = new TurkeyAdapter(turkey);
		
		System.out.println("The Turkey says.....");
		turkey.gobble();
		turkey.fly();
		
		System.out.println("\nThe Duck says.....");
		testDuck(duck);
		
		System.out.println("\nThe TurkeyAdapter says.....");
		testDuck(turkeyAdapter);
	}
	
	static void testDuck(Duck duck) {
		duck.quack();
		duck.fly();
	}
}

퍼사드 패턴(Facade Pattern)

정의

public class Facade {
	// 우리가 사용하고자 하는 서브시스템의 모든 구성요소들이 인스턴스 변수 형태로 저장 됩니다.
	DvdPlayer dvd;
	Light light;
	Screen screen;
	
	public Facade(DvdPlayer dvd, Light light, Screen screen) {
		this.dvd = dvd;
		this.light = light;
		this.screen = screen;
	}
	// 하나하나 수동으로 작업 했던 내용들을 하나의 메소드로 순서대로 처리 합니다.
	//  각 작업은 서브시스템에 들어있는 구성요소들에게 위임 됩니다.
	public watchMove(String movie) {
		dvd.on();
		light.on();
		dvd.open();
		dvd.insert();
		screen.on();
		dvd.play();
	}
}

// station으로부터 thermometer라는 객체를 받은 다음, 그객체의 
// getTemperature() 메소드를 직접 호출 합니다.
public float getTemp() {
	Thermometer thermometer = station.getThermometer();
	return thermometer.getTemperature();
}

// 최소 지식 원칙을 적용하여 Station 클래스에 thermometer에 요청을 해 주는
// 메소드를 추가했습니다. 이렇게 하면 의존해야 하는 클래스의 개수를 줄일 수 있죠.
public float getTemp() {
	return station.getTemperature();
}

 
public class Car {
	// 클래스의 구성요서. 이 구성요소의 메소드는 호출해도 되죠.
	Engine engine;
	// 기타 인스턴스 변수
	
	public Car() {
		// 엔진 초기화 등을 처리
	}
	
	public void start(Key key) {
		// 새로운 객체를 생성 합니다. 이 객체의 메소드는 호출해도 됩니다.
		Doors doors = new Doors();
		// 매개변수로 전달된 객체의 메소드는 호출해도 됩니다.
		boolean authorized = key.turns();
		
		if (authorized) {
			// 이 객체의 구성요소의 메소드는 호출해도 되죠?
			engine.start();	
			// 객체 내에 있는 메소드는 호출해도 됩니다.
			updateDashboardDisplay();
			// 직접 생성하거나 인스턴스를 만든 객체의 메소드는 호출해도 됩니다.
			doors.lock();	
		}
		
	}
	
	public void updateDashboardDisplay() {
		// 디스플레이 갱신
	}
}

정의
요구 사항을 객체로 캡슐화 할 수 있으며, 매개변수를 써서 여러 가지 다른 요구 사항을 집어넣을 수도 있습니다. 또한 요청 내역을 큐에 저장하거나 로그로 기록할 수도 있으며, 작업취소 기능도 지원 가능 합니다.
어떤 작업을 요청한 쪽하고 그 작업을 처리한 쪽을 분리시킬 수 있다.

Command noCommand = new NoCommand();
onCommand = noCommand
// 널 객체를 사용하면 if 문을 생략하고 사용할 수 있음.
if (onCommand != null)
    onCommand.execute();

public class MacroCommand implements Command {
    Command[] command;
    public MacroCommand(Command[] command) {
        this.command = command;
    }
    public void execute() {
        for (int i = 0; i < command.length; i++) {
            command[i].execute();
        }
    }
    public void undo() {
        for (int i = 0; i < command.length; i++) {
            command[i].undo();
        }
    }
}

public class Singleton {
    private static Singleton instance;

    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Singleton {
    private static Singleton instance;	
    private Singleton() {}	
    /**
     * getInstance()에 synchronized 키워드만 추가하면 한 스레드가 
     * 메소드 사용을 끝내기 전까지 다른 스레드는 기다려야 합니다.
     * 즉, 두 스레드가 이메소드를 동시에 실행시킬 수 없습니다.
     */
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

public class Singleton {
    private static Singleton instance = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return instance;
    }
}

public class Singleton {
    // 1.5 이전의 버전에서는 volatile 키워드를 사용 할 수 없습니다.
    private volatile static Singleton instance;
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            // 이 방법을 사용 하면 처음에 한번만 동기화가 된다.
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

public class PizzaStore {
    Pizza orderPizza(String type) {
        Pizza pizza;
        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        }
        pizza.prepare(); 
        pizza.bake(); 
        piaaz.cut();
        pizza.box();
        reutnr pizza;
    }
}

public class SimplePizzaFactory {
    public Pizza create Pizza(String type) {
        Pizza pizza = null;
        if (type.equals("cheese")) {
            pizza = new CheesePizza();
        } else if (type.equals("pepperoni")) {
            pizza = new PepperoniPizza();
        }
        return pizza;
    }
}

NYPizzaFactory nyFactory = new NYPizzaFactory();
PizzaStore nyStore = new PizzaStore(nyFactory);
nyStore.order("cheese");

문제점
분점에서 독자적인 방법들을 사용하기 시작했습니다.
굽는 방식이 달라진다거나 피자를 자르는 것을 까먹어 버리는일, 이상한 피자 상자를 사용 등
그래서 피자 가게와 피자 제작 과정 전체를 하나로 묶어주는 프레임워크를 만들어야 겠다는 결론에 도달했습니다.

피자를 만드는 활동 자체는 전부 PizzaStore 클래스에 국한시키면서도 분점마다 고유의 스타일을 살릴 수 있도록 하는 방법이 있습니다.

createPizza() 를 PizzaStore에 다시 넣고 그 메소드를 추상 메소드로 선언하고, 각 분점마다 고유의 스타일에 맞게 PizzaStore의 서브클래스를 만들도록 할 것입니다.

public abstract class PizzaStore {

    public Pizza orderPizza(String type) {
        Pizza pizza;

        pizza = createPizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();
        return pizza;
    }
    abstract Pizza createPizza(String type);
}