Java 建造者模式_编程设计

1.建造者模式简介

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创
建对象的最佳方式。一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

意图：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。
主要解决：主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变
化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。
何时使用：一些基本部件不会变，而其组合经常变化的时候。
如何解决：将变与不变分离开。

优点：(1)建造者独立，易扩展。(2)便于控制细节风险。
缺点：(1)产品必须有共同点，范围有限制。 (2)如内部变化复杂，会有很多的建造类。
使用场景：(1)需要生成的对象具有复杂的内部结构。 (2)需要生成的对象内部属性本身相互依赖。

注意事项：与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

2.创建者模式Demo
去肯德基，汉堡、可乐、薯条、炸鸡翅等是不变的，而其组合是经常变化的，生成出所谓的"套餐"。

继承关系图：

import java.util.ArrayList; 
import java.util.List; 
 
interface Packing { 
    public String pack(); 
} 
 
class Wraper implements Packing { 
    public String pack() { 
        return "Wraper"; 
    } 
} 
 
class Bottle implements Packing { 
    public String pack() { 
        return "Bottle"; 
    } 
} 
 
interface Item { 
    public String name(); 
    public Packing pack(); 
    public float price();  
} 
 
 
abstract class Burger implements Item { 
    @Override 
    public Packing pack() { 
        return new Wraper(); //效果是什么？ 
    } 
} 
 
class VegBurger extends Burger { 
    @Override 
    public String name() { 
        return "VegBurger"; 
    } 
    @Override 
    public float price() { 
        return 30.0f; 
    } 
} 
 
class NonVegBurger extends Burger { 
    @Override 
    public String name() { 
        return "NonVegBurger"; 
    } 
    @Override 
    public float price() { 
        return 38.0f; 
    } 
} 
 
abstract class ColdDrink implements Item { 
    @Override 
    public Packing pack() { 
        return new Bottle(); //效果是什么？ 
    } 
} 
 
class Coke extends ColdDrink { 
    @Override 
    public String name() { 
        return "Coke"; 
    } 
    @Override 
    public float price() { 
        return 5.0f; 
    } 
} 
 
class Pepsi extends ColdDrink { 
    @Override 
    public String name() { 
        return "Pepsi"; 
    } 
    @Override 
    public float price() { 
        return 6.0f; 
    } 
} 
 
 
class Meal { 
    private ArrayList<Item> items = new ArrayList<Item>(); 
 
    public void addItem(Item item) { 
        items.add(item); 
    } 
 
    public float mealPrice() { 
        float totalPrice = 0.0f; 
        for (Item i : items) { 
            totalPrice += i.price(); 
        } 
        return totalPrice; 
    } 
 
    public String mealItemList() { 
        String s = ""; 
        for (Item i : items) { 
            s += "Name: "; 
            s += i.name(); 
            s += ", Packing: "; 
            s += i.pack().pack(); /*i.pack()返回的是Wraper类对象*/ 
            s += ", Price: "; 
            s += i.price(); 
            s += "\n"; 
        } 
        return s; 
    } 
} 
 
class MealBuilder { 
    public static Meal perpareVegMeal() { 
        Meal meal = new Meal(); 
        meal.addItem(new VegBurger()); /*VegBurger是Item类的孙子，同样能表现出多态*/ 
        meal.addItem(new Coke()); 
        meal.addItem(new Pepsi()); /*若这个套餐中又加了一杯百世可乐，直接在这里加上一行即可。*/ 
        return meal; 
    } 
    public static Meal perpareNonVegMeal() { 
        Meal meal = new Meal(); 
        meal.addItem(new NonVegBurger()); 
        meal.addItem(new Pepsi()); 
        return meal; 
    } 
} 
 
public class BuilderPatternDemo { 
    public static void main(String args[]) { 
        Meal meal1 = MealBuilder.perpareVegMeal(); 
        System.out.print(meal1.mealItemList()); 
        System.out.println("TotalPrice: " + meal1.mealPrice()); 
 
        Meal meal2 = MealBuilder.perpareNonVegMeal(); 
        System.out.print(meal2.mealItemList()); 
        System.out.println("TotalPrice: " + meal2.mealPrice()); 
    } 
 
} 
 
/* 
执行结果： 
Name: VegBurger, Packing: Wraper, Price: 30.0 
Name: Coke, Packing: Bottle, Price: 5.0 
Name: Pepsi, Packing: Bottle, Price: 6.0 
TotalPrice: 41.0 
Name: NonVegBurger, Packing: Wraper, Price: 38.0 
Name: Pepsi, Packing: Bottle, Price: 6.0 
TotalPrice: 44.0 
*/

参考：http://www.runoob.com/design-pattern/builder-pattern.html

本文参考链接：https://www.cnblogs.com/hellokitty2/p/10663436.html