U E D R , A S I H C RSS

니젤프림/Builder Pattern

1. Builder Pattern


빌더 다. 빌더 는 방법과, 는 방법 다. 리로 과는, 동 다른 게 되는 것다.

게 말, 는데, 그 는게 라, Builder 는 것다. 그런데 꾸 나/ 미는, 바로 director 다고 다. director 는 Building step(construction process) 고 concrete builder 는 product (representation) .. 그리고, builder 가 므로 director 는 그것 는 것다.

1.1. 나?

때. 가?

1.2. 되는

()랑 맥날드 만들내는 를 들 다. , 드, 료, 난감 (, , 라, 매달 바뀌는 난감) 다. , 릿 다는 것다. 까다로 릴때부날드 려면 당 바리 다. 고객 나, 면 맥 만, 기본되는 방는 변 다. 빌더 다면, Director 라고 다. 물론 고객 Customer 다. 고객 는 바리 를 구게 되면 (Customer가 Concrete Builder 를 다) Director 는 릿 따라 (Concrete Builder) (Product) 를 만들 낸다. Director 가 Concrete Builder 는 방 따라 므로 그것 를 Builder 라고 겠다.



1.3.1. Builder

Product 를 릿. Abstract Interface 라고 다.

1.3.2. Concrete Builder

Builder 를 구. 로 다 Concrete Builder 가 며, Builder 가 late binding 게 된다. 물론, builder pattern 는 Product 를 만들내는 것다.

1.3.3. Director

Director 는 Product 를 는 방법과 다. Builder 를 가기 때문 Concrete Builder 를 Builder 다.

1.3.4. Product

만들 . 로 Builder Pattern 는 Product 는 Composite Pattern 다.

1.4.

1.4.1. Wikipedia Java code

/** "Product" */
class Pizza {
  private String dough = "";
  private String sauce = "";
  private String topping = "";

  public void setDough (String dough)     { this.dough = dough; }
  public void setSauce (String sauce)     { this.sauce = sauce; }
  public void setTopping (String topping) { this.topping = topping; }
}


/** "Abstract Builder" */
abstract class PizzaBuilder {
  protected Pizza pizza;

  public Pizza getPizza() { return pizza; }
  public void createNewPizzaProduct() { pizza = new Pizza(); }

  public abstract void buildDough();
  public abstract void buildSauce();
  public abstract void buildTopping();
}

/** "ConcreteBuilder" */
class HawaiianPizzaBuilder extends PizzaBuilder {
  public void buildDough()   { pizza.setDough("cross"); }
  public void buildSauce()   { pizza.setSauce("mild"); }
  public void buildTopping() { pizza.setTopping("ham+pineapple"); }
}

/** "ConcreteBuilder" */
class SpicyPizzaBuilder extends PizzaBuilder {
  public void buildDough()   { pizza.setDough("pan baked"); }
  public void buildSauce()   { pizza.setSauce("hot"); }
  public void buildTopping() { pizza.setTopping("pepperoni+salami"); }
}


/** "Director" */
class Waiter {
  private PizzaBuilder pizzaBuilder;

  public void setPizzaBuilder (PizzaBuilder pb) { pizzaBuilder = pb; }
  public Pizza getPizza() { return pizzaBuilder.getPizza(); }

  public void constructPizza() {
    pizzaBuilder.createNewPizzaProduct();
    pizzaBuilder.buildDough();
    pizzaBuilder.buildSauce();
    pizzaBuilder.buildTopping();
  }
}

/** A customer ordering a pizza. */
class BuilderExample {
  public static void main(String[] args) {
    Waiter waiter = new Waiter();
    PizzaBuilder hawaiianPizzaBuilder = new HawaiianPizzaBuilder();
    PizzaBuilder spicyPizzaBuilder = new SpicyPizzaBuilder();

    waiter.setPizzaBuilder ( hawaiianPizzaBuilder );
    waiter.constructPizza();

    Pizza pizza = waiter.getPizza();
  }
}

1.4.2. Composite Pattern 는 Builder Pattern

Head First Design Pattern 는, Vacation Planner 를 구
1.4.2.1. nijel.product
// PlanComponent
package nijel.product;

public class PlanComponent {	
	protected String name;
	protected String description;

	public PlanComponent(String name, String description) {
		this.name = name;
		this.description = description;
	}
	
	public void add(PlanComponent planComponent) {
		throw new UnsupportedOperationException();
	}
	
	public void remove(PlanComponent planComponent) {
		throw new UnsupportedOperationException();
	}
	public PlanComponent getChild(int index) {
		throw new UnsupportedOperationException();
	}
	
	public String getName() {
		throw new UnsupportedOperationException();
	}
	
	public String getDescription() {
		throw new UnsupportedOperationException();
	}
	
	public void print() {
		throw new UnsupportedOperationException();
	}
}

// Plan
package nijel.product;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

public class Plan extends PlanComponent {
	private List<PlanComponent> planComponents;

	public String getName() {
		return name;
	}
	
	public String getDescription() {
		return description;
	}
	
	public Plan(String name, String description) {
		super(name, description);
		
		planComponents = new ArrayList<PlanComponent>();
	}

	public void add(PlanComponent planComponent) {
		planComponents.add(planComponent);
	}

	public PlanComponent getChild(int index) {
		return planComponents.get(index);
	}

	public void remove(PlanComponent planComponent) {
		planComponents.remove(planComponent);
	}
	
	public void print() {
		System.out.println("\n" + getName());
		System.out.println(", " + getDescription());
		System.out.println("------------------------------");
		
		Iterator iterator = planComponents.iterator();
		while (iterator.hasNext()) {
			PlanComponent planComponent = (PlanComponent) iterator.next();
			planComponent.print();
		}
	}
}

// PlanItem
package nijel.product;

public class PlanItem extends PlanComponent {
	
	public PlanItem(String name, String description) {
		super(name, description);
	}
	
	public String getName() {
		return name;
	}
	
	public String getDescription() {
		return description;
	}
	
	public void print() {
		System.out.println("\t" + getName() + "\n");
		System.out.println("\t\t" + getDescription() + "\n");
	}
}


1.4.2.2. nijel.builder
// director
package nijel.builder;

import nijel.product.PlanComponent;

public abstract class Planner {
	abstract public PlanComponent makePlan();
}

// concrete director
package nijel.builder;

import nijel.product.PlanComponent;

public class MyPlanner extends Planner {
	
	private Builder builder;

	public MyPlanner(Builder builder) {
		this.builder = builder;
	}
	
	public PlanComponent makePlan() {
		int first, second, third;
		
		first = 1;
		builder.buildDay(first);
		
		builder.addHotel(first, "Patternsland 5 star Hotel");
		builder.addTickets(first, "Park Ticket: R");
		builder.addReservation(first, "Dinner at VERY expensive French restaurant");
		
		second = 2;
		builder.buildDay(second);
		
		builder.addHotel(second, "Maybe Hotel");
		builder.addTickets(second, "Park Ticket: A");
		builder.addSpecialEvent(second, "Patterns on Ice");
		builder.addReservation(second, "just dinner");
		
		third = 3;
		builder.buildDay(third);
		builder.addHotel(third, "Wannabe Hotel");
		builder.addTickets(third, "Ticket for Children!");
		
		return builder.getVacationPlan();
	}
}

// builder
package nijel.builder;

import nijel.product.PlanComponent;

public interface Builder {
	abstract public void buildDay(int date);
	abstract public void addHotel(int date, String hotel);
	abstract public void addTickets(int date, String ticket);
	abstract public void addSpecialEvent(int date, String event);
	abstract public void addReservation(int date, String restaurant);
	
	abstract public PlanComponent getVacationPlan();
}

// concrete builder
package nijel.builder;

import nijel.product.Plan;
import nijel.product.PlanComponent;
import nijel.product.PlanItem;

public class VacationBuilder implements Builder {
	private PlanComponent plan;
	
	public VacationBuilder(String description) {
		plan = new Plan(description);
	}
	
	public void addHotel(int date, String hotel) {
		PlanComponent hotelReservation = new PlanItem(hotel);
		
		plan.getChild(date - 1).add(hotelReservation);
	}

	public void addSpecialEvent(int date, String event) {
		PlanComponent specialEvent = new Plan("Special Event");
		specialEvent.add(new PlanItem(event));
		
		plan.getChild(date - 1).add(specialEvent);
	}

	public void addTickets(int date, String ticket) {
		PlanComponent admissionTicket = new PlanItem(ticket);
		
		plan.getChild(date - 1).add(admissionTicket);
	}

	public void buildDay(int date) {
		plan.add(new Plan(date + "day's plan"));
	}

	public PlanComponent getVacationPlan() {
		return plan;
	}

	public void addReservation(int date, String restaurant) {
		PlanComponent reservation = new Plan("Dining");
		reservation.add(new PlanItem(restaurant));
		
		plan.getChild(date - 1).add(reservation);
		
	}
}




1.4.2.3. nijel.client
package nijel.client;

import nijel.builder.*;
import nijel.product.*;

public class Client {
	public static void main(String[] args) {
		PlanComponent perfectVacationPlan;
		Planner perfectPlanner =
					new MyPlanner(new VacationBuilder("Perfect Vacation Plan"));
		
		perfectVacationPlan = perfectPlanner.makePlan();
		
		perfectVacationPlan.print();
	}
}

1.5. Builder Pattern 과 Abstract Factory Pattern

Builder Pattern 과 Abstract Factory Pattern 다. 라면 미묘다고 는데, Abstract Factory Pattern 만들는가 고, Builder Pattern 떻게 만들 는가 다고 다. 물론 두 Creational Pattern Product 는데 다. 가 라면, Builder Pattern 만들 고, Abstract Factory Pattern generic product 를 concrete factory 가 기 때문 각각 가 만들다 product 를 게 된다.

Abstract Factory Pattern : 다. (다) 를 들면, 메뉴를 는 것다. (interface to factory)는 " 리" 라는 abstract generic message 를 방(concrete factory) 게 될 때 concrete product 를 게 되는 것다.

Builder Pattern : 복 떤 방 만들 방법 다. (encapsulate) 를 들면, 때, (builder) (product 곽)를 (complex object) 만들 낸다.

.
http://en.wikipedia.org/wiki/Builder_pattern
Valid XHTML 1.0! Valid CSS! powered by MoniWiki
last modified 2021-02-07 05:28:55
Processing time 0.0220 sec