Model Builder

Builder mode (Builder Pattern) using a plurality of simple objects to build step by step into a complex object. This type of design patterns belong create schema, which provides the best way to create objects.

Builder class is a step by step to construct the final object. The Builder class is independent of the other objects.

Introduction

Intent: a complex build its representation separation, so that the same construction process can create different representations.

Mainly to solve: the main solution in the software system, sometimes facing "a complex object" to create work, which is usually a certain algorithm consists of various parts of the sub-object; due to changes in demand, the various parts of this complex subject often face a drastic change, but they will combine algorithm is relatively stable.

When to use: it will not change some of the basic components, and combinations thereof constantly changing times.

How to fix: the changed and unchanged separated.

The key code: Builder: Create and provide examples, Director: dependency management built out instance.

Application examples: 1, go to KFC, burgers, cola, french fries, fried chicken wings, etc. is constant, and its composition is constantly changing, generating a so-called "package."2, JAVA in StringBuilder.

Advantages: 1, an independent builder, easy to expand.2, easy to control the details of risk.

Disadvantages: 1, the product must have in common, the range is limited.2. The complex internal changes, there will be a lot of construction classes.

Usage scenarios: 1, you need to generate the object has a complex internal structure.2, need to be generated inside the object property itself interdependent.

Note: The difference between the plant model is: Builder model is more concerned with the order of assembly of the parts.

achieve

We assume that a fast-food restaurant business case, in which a package can be a typical burger (Burger) and a glass of cold (Cold drink). Burger (Burger) can be veggie burgers (Veg Burger) or chicken burgers (Chicken Burger), they are wrapped in the paper tray. Cold (Cold drink) may be a Coca-Cola (coke) or Pepsi (pepsi), they are packed in bottles.

We will create a representation of food items (such as burgers and cold) ofIteminterface and implementation entity classIteminterface, and an interface and implementation entity representsPackingfoods packagingPackinginterface, Hamburg is the package in the paper tray is cold packed in bottles.

Then we create aMealclasses, ArrayList and aMealto create different types of objects through a combination ofItemMealBuilder withItem.BuilderPatternDemo, we demonstrate the use ofMealBuilderclass to create aMeal.

step 1

Creates a food and food packaging entry interface.

Item.java

public interface Item {
   public String name ();
   public Packing packing ();
   public float price ();	
}

Packing.java

public interface Packing {
   public String pack ();
}

Step 2

Packing create entity classes implement the interface.

Wrapper.java

public class Wrapper implements Packing {

   @Override
   public String pack () {
      return "Wrapper";
   }
}

Bottle.java

public class Bottle implements Packing {

   @Override
   public String pack () {
      return "Bottle";
   }
}

Step 3

Create An abstract class Item interface, the class provides a default function.

Burger.java

public abstract class Burger implements Item {

   @Override
   public Packing packing () {
      return new Wrapper ();
   }

   @Override
   public abstract float price ();
}

ColdDrink.java

public abstract class ColdDrink implements Item {

	@Override
	public Packing packing () {
       return new Bottle ();
	}

	@Override
	public abstract float price ();
}

Step 4

Creating an extension of the entity classes Burger and ColdDrink.

VegBurger.java

public class VegBurger extends Burger {

   @Override
   public float price () {
      return 25.0f;
   }

   @Override
   public String name () {
      return "Veg Burger";
   }
}

ChickenBurger.java

public class ChickenBurger extends Burger {

   @Override
   public float price () {
      return 50.5f;
   }

   @Override
   public String name () {
      return "Chicken Burger";
   }
}

Coke.java

public class Coke extends ColdDrink {

   @Override
   public float price () {
      return 30.0f;
   }

   @Override
   public String name () {
      return "Coke";
   }
}

Pepsi.java

public class Pepsi extends ColdDrink {

   @Override
   public float price () {
      return 35.0f;
   }

   @Override
   public String name () {
      return "Pepsi";
   }
}

Step 5

Create a Meal class, with the Item object defined above.

Meal.java

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

public class Meal {
   private List <Item> items = new ArrayList <Item> ();	

   public void addItem (Item item) {
      items.add (item);
   }

   public float getCost () {
      float cost = 0.0f;
      for (Item item: items) {
         cost + = item.price ();
      }		
      return cost;
   }

   public void showItems () {
      for (Item item: items) {
         System.out.print ( "Item:" + item.name ());
         System.out.print ( ", Packing:". + Item.packing () pack ());
         System.out.println ( ", Price:" + item.price ());
      }		
   }	
}

Step 6

MealBuilder create a class, the actual builder responsible for creating Meal class object.

MealBuilder.java

public class MealBuilder {

   public Meal prepareVegMeal () {
      Meal meal = new Meal ();
      meal.addItem (new VegBurger ());
      meal.addItem (new Coke ());
      return meal;
   }   

   public Meal prepareNonVegMeal () {
      Meal meal = new Meal ();
      meal.addItem (new ChickenBurger ());
      meal.addItem (new Pepsi ());
      return meal;
   }
}

Step 7

BuiderPatternDemo use MealBuider to demonstrate builder mode (Builder Pattern).

BuilderPatternDemo.java

public class BuilderPatternDemo {
   public static void main (String [] args) {
      MealBuilder mealBuilder = new MealBuilder ();

      Meal vegMeal = mealBuilder.prepareVegMeal ();
      System.out.println ( "Veg Meal");
      vegMeal.showItems ();
      System.out.println ( "Total Cost:" + vegMeal.getCost ());

      Meal nonVegMeal = mealBuilder.prepareNonVegMeal ();
      System.out.println ( "\ n \ nNon-Veg Meal");
      nonVegMeal.showItems ();
      System.out.println ( "Total Cost:" + nonVegMeal.getCost ());
   }
}

Step 8

Verify output.

Veg Meal
Item: Veg Burger, Packing: Wrapper, Price: 25.0
Item: Coke, Packing: Bottle, Price: 30.0
Total Cost: 55.0


Non-Veg Meal
Item: Chicken Burger, Packing: Wrapper, Price: 50.5
Item: Pepsi, Packing: Bottle, Price: 35.0
Total Cost: 85.5