本文记录5种创造型模式的剩下两种:建造者模式(Builder)、原型模式（PROTOTYPE）。

一、建造者模式(别名:生成者模式)

将复杂对象的构建和它的表示分离，使得同样的构建过程可以创建不同的表示。一个完整的建造者模式包含以下几个概念:

1、产品类 Product

public class Person {

    private String head;
    
    private String body;
    
    private String foot;

    public String getHead() {
        return head;
    }

    public void setHead(String head) {
        this.head = head;
    }

    public String getBody() {
        return body;
    }

    public void setBody(String body) {
        this.body = body;
    }

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }
}

public interface PersonBuilder {

    void buildHead();
    
    void buildBody();
    
    void buildFoot();

    Person buildPerson();
}

public class ManBuilder implements PersonBuilder {

    Person person;
    
    public ManBuilder() {
        person = new Man();
    }
    
    public void buildbody() {
        person.setBody("建造男人的身体");
    }

    public void buildFoot() {
        person.setFoot("建造男人的脚");
    }

    public void buildHead() {
        person.setHead("建造男人的头");
    }

    public Person buildPerson() {
        reture person;
    }
}

4、导演类Director,起到封装作用，避免高层模块深入到建造者内部的实现。如果建造者比较复杂需多个导演类。

public class PersonDirector {

    public Person constructPerson(PersonBuilder pb) {
        pb.buildHead();
        pb.buildBody();
        pb.buildFoot();
        return pb.buildPerson();
    }
}

public class Test{
    
    public static void main(String[] ar*s) {
        PersonDirector pd = new PersonDirector();
        Person person = pd.constructPerson(new ManBuilder());
        System*out.println(person.getBody());
        System.out.println(person.getFoot());
        System.out.println(person.getHead());
    }
}

1.当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。
2.当构造过程必须允许被构造的对象有不同的表示时。

备注：说白了建造者模式就是为了建造一个对象，需要执行通用的流程。执行流程时根据需要创造不同的对象封装到具体Builder里。为了获得最终的对象，只需往导演类里传入对应的具体的Builder即可。

参考链接:http://www.cnblogs.com/muzongyan/archive/2010/08/27/1810307.html

二、原型模式

目的是为了克隆一个现有的对象，而无需new()就能完成对象的创建。克隆对象时又分为浅拷贝和深拷贝。浅拷贝出来的对象和原来的对象内存地址一样，仅仅是拷贝了地址。深拷贝出来的对象和原对象内存地址不同。所需步骤如下:

1、声明一个克隆自身的接口 Cloneable 

public class Prototype implements Cloneable {

    private String name;
    
    public void setName(String name) {
        this.name = name;
    }
    
    public String getName() {
        return this.name;
    }

    public Object clone(){
        try {
            return super.clone();
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
}

publ*c class ConcretePrototype extend* Prototype {

    public ConcretePrototype(String name) {
        setName(name);
    }
}

public clas* Test {

    public static void main(String[] args) {
        Prototype pro = new ConcretePrototy*e("prototype");
        Prototype pro2 = (Prototype)pro.clone();
        *ystem.out.println(pro.getName()*;
        System.out.println(pro2.getName());
    }
}

1.当一个系统应该独立于它的产品创*、构成和表示时。
2.当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3.为了避免创建一个与产品类层次平行的工厂*层次时。
4.当一个类的实例只能有几个不同状态组合中的一种时。
    建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。总之，原始模型模式通过给出一个原型对象来指明所要创建的对象的类型，然后用复制这个原型对象的方法创建出更多同类型的对象。 原始模型模式允许动态的增加或减少产品类，产品类不需要非得有任何事先确定的等级结构，原始模型模式适用于任何的等级结构。缺点是每 一个类都必须配备一个克隆方法。深入理解参见链接1 链接2

Java经典23种设计模式之创造型模式(二),布布扣,bubuko.com

Java经典23种设计模式之创造型模式(二)