创造型模式 - 建造者模式

个人理解：    
    一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
    

    在搜索了众多的建造者模式后，我发现，有的给出的建造者目的是为了封装产品不同的顺序，有的是同样的顺序不同的产品，有的顺序是封装在Director中，有的都不封装，而是延迟到Client中再定。其实它们都是可以的，因为:"创建者将一个复杂对象的构建与它的表示分离"。

    但是，既然建造者主要用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。那么建造者中的一个非常重要的类就是指挥者（Director）类，它用来控制建造过程，也用它来隔离用户与建造过程的关联。所以，应该将顺序的变化或产生的不同的产品都应该在Director中办喽。

模式类型：

    builder 建造者模式 - 创建型模式

概述:
    建造者模式(Builder Pattern)也叫做生成器模式，其定义如下：
    Separate the construction of a complex object from its representation so that the same construction process can create different representations. 将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
   
    四个要素
    产品类：一般是一个较为复杂的对象，也就是说创建对象的过程比较复杂，一般会有比较多的代码量。在本类图中，产品类是一个具体的类，而非抽象类。实际编程中，产品类可以是由一个抽象类与它的不同实现组成，也可以是由多个抽象类与他们的实现组成。
    抽象建造者：引入抽象建造者的目的，是为了将建造的具体过程交与它的子类来实现。这样更容易扩展。一般至少会有两个抽象方法，一个用来建造产品，一个是用来返回产品。
    建造者：实现抽象类的所有未实现的方法，具体来说一般是两项任务：组建产品；返回组建好的产品。
    导演类：负责调用适当的建造者来组建产品，导演类一般不与产品类发生依赖关系，与导演类直接交互的是建造者类。一般来说，导演类被用来封装程序中易变的部分。
    
建造者模式的应用场景
    1.创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。
    2.要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

结构图

建造者模式的优缺点
    1、封装性  使用建造者模式可以使客户端不必知道产品内部组成的细节。
    2、建造者独立，容易扩展，对系统的扩展非常有利。
    3、便于控制细节风险。由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。
    
建造者模式的应用实例

注意：
    建造者模式和工厂模式非常相似，但是：建造者模式最主要功能是基本方法的调用顺序安排，也就是这些基本方法已经实现了，通俗的说就是零件的装配，顺序不同产生的对象也不同。组装顺序不同对象效能也不同，这才是建造者模式要表达的核心意义，而怎么才能更好的达到这种效果呢？引入模板方法模式是一个非常简单而有效的办法。；而工厂方法则重点是创建，创建零件时它的主要职责，你要什么对象我创造一个对象出来，组装顺序则不是他关心的。
    
代码（其实读UML图要比代码还要一目了然）
我觉得这个例子还是有代表性的，因为它满足了："构建过程可以创建不同的表示"。

/* "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 hawaiian_pizzabuilder = new HawaiianPizzaBuilder();
    PizzaBuilder spicy_pizzabuilder = new SpicyPizzaBuilder();

    waiter.setPizzaBuilder( hawaiian_pizzabuilder );
    waiter.constructPizza();

    Pizza pizza = waiter.getPizza();
  }
}

另一个例子：
一个典型的复杂类对象代码示例如下：
   

class Productor {
            private Part partA;
            private Part partB;
            private Part partC;

            // 这些是各个部件的set和get的方法，在此省略。。。
    }
    //这是抽象的Builder：
    abstract class Builder {
            public abstract void buildPartA();
            public abstract void buildPartB();
            public abstract void buildPartC();
    }
    //继承Builder的具体的建造者：
    class ConcreteBuilder extends Builder {
            private Product product;
            // 创建partA
            public void buildPartA() {
                    // 在此创建出部件
                    Part partA = new PartA();
                    // ......

                    // 把partA传递给product
                    product.setPartA(partA);
            }
            // 创建partB
            public void buildPartB() {
                    // 在此创建出部件
                    Part partB = new PartB();
                    // ......

                    // 把partB传递给product
                    product.setPartA(partB);
            }
            // 创建partC
            public void buildPartC() {
                    // 在此创建出部件
                    Part partC = new PartC();
                    // ......

                    // 把partC传递给product
                    product.setPartA(partC);
            }  
            // 返回复杂产品对象
            public void getProduct() {
                return this.product;
            }     
    }
    //这是导演，负责流程规范，在导演类中可以注入建造者对象。
    class Director {
            private Builder concretebuilder;
            // 构造方法中也可以传递builder
            public Director(Builder builder) {
                    this.concretebuilder = builder;
            }
            // 传递builder
            public void setBuilder(Builder builder) {
                    this.concretebuilder = builder;
            }
            // 这个方法用来规范流程，产品构建和组装方法
            public void construct() {
                    builder.buildPartA();
                    builder.buildPartB();
                    builder.buildPartC();
            }
    }
    // 客户端使用：
    class Main {
            public static void main(String[] args) {
                    // 对于客户端而言，只需要关心具体的建造者，无需关心产品内部构建流程。我如果需要其他的复杂产品对象，只需要选择其他的建造者，如果需要扩展，则只需要写一个新的builder就行。如果可以，这个建造者甚至可以用配置文件做，增加更多的扩展性。
                    Builder builder = new ConcreteBuilder();
                    // 把建造者注入导演
                    Director director = new Director(builder);
                    // 指挥者负责流程把控
                    director.construct();
                    // 建造者返回一个组合好的复杂产品对象
                    Productor productor = builder.getProductor();
            }
    }

所有模式

     创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。
结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。
    行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
    补充模式：空对象模式
    
参考/转自
    http://www.oodesign.com/builder-pattern.html
    http://sourcemaking.com/design_patterns/builder
    http://sourcemaking.com/design_patterns/builder/java/2
    http://sourcemaking.com/design_patterns/builder/java/1
    http://blog.csdn.net/hello_haozi/article/details/38819935
    http://www.cnblogs.com/cbf4life/archive/2010/01/14/1647710.html
    http://www.cnblogs.com/BeyondAnyTime/archive/2012/07/19/2599980.html
    http://blog.csdn.net/ljianhui/article/details/8280594

转载请注明：http://blog.csdn.net/paincupid/article/details/43865915