设计模式之Builder构建者模式

1.定义
使复杂对象的构建与表示分离，使同样的构建过程有不同的表示。
2.使用场景
（1）相同的方法，不同的执行顺序，产生不同的事件结果时。
（2）多个部件或零件，都可以装配到一个对象中，但是产生的运行结果又不相同时。
（3）产品类非常复杂，或者产品类中的调用顺序不同产生了不同的作用，这个使用建造者模式非常适合。
（4）当初始化一个对象特别复杂时，如参数多，且很多参数有默认值。
3.第一种经典的实现方式
Client Director Builder Product模式

（转）
简单地说，就好象我要一座房子住，可是我不知道怎么盖（简单的砌墙，层次较低），也不知道怎么样设计（建几个房间，几个门好看，层次较高），于是我需要找一帮民工，他们会砌墙，还得找个设计师，他知道怎么设计，我还要确保民工听设计师的领导，而设计师本身也不干活，光是下命令，这里砌一堵墙，这里砌一扇门，这样民工开始建设，最后，我可以向民工要房子了。在这个过程中，设计师是什么也没有，除了他在脑子里的设计和命令，所以要房子也是跟民工要，记住了！

最终的产品：Product (Room)

public class Room {

    private String window;
    private String floor;

    public void setWindow(String window){
        this.window = window;
    }
    public void setFloor(String floor){
        this.floor = floor;
    }

    public String getWindow(){
        return window;
    }

    public String getFloor(){
        return floor;
    }
    @Override
    public String toString() {
        return "{\"window\":\"" + window + "\",\"floor\":\"" + floor + "\"}";
    }

}

Buidler构建者接口,功能就是建窗户，建地板，最终将Product交付给Client

public interface Builder {

    public void makeWindow();

    public void makeFloor();

    public Room returnRoom();
}

Buidler的实现

public class RoomBuilder implements Builder{

    private Room room = new Room();

    @Override
    public void makeWindow() {
        room.setWindow("Window");
    }

    @Override
    public void makeFloor() {
        room.setFloor("Floor");
    }

    @Override
    public Room returnRoom() {
        return room;
    }

}

Director 指挥Builder如何工作（构建顺序）

public class Director {

    public void command(Builder builder){
        //先建造窗户
        builder.makeWindow();
        //然后建造地板
        builder.makeFloor();
    }

}

Client拿到产品Product (Room)

public class Client {

    public static void main(String[] args) {
        //工人建造Product
        Builder build = new RoomBuilder();

        Director director = new Director();
        //Director指挥工人的工作顺序
        director.command(build);
        //最终将Product交给Client
        Room room = build.returnRoom();

        System.out.println(room.toString());
    }
}

3.第二种内部类的实现方式（目前通用的写法）

public class Person {

    private String name;
    private String age;
    private String weight;
    private String height;

    private Person(Builder builder){
        this.name = builder.name;
        this.age = builder.age;
        this.weight = builder.weight;
        this.height = builder.height;
    }

    public String getName() {
        return name;
    }

    public String getAge() {
        return age;
    }

    public String getWeight() {
        return weight;
    }

    public String getHeight() {
        return height;
    }

    static class Builder{
        private String name;
        private String age;
        private String weight;
        private String height;

        public Person build(){
            return new Person(this);
        }

        public Builder name(String name){
            this.name = name;
            return this;
        }

        public Builder age(String age){
            this.age = age;
            return this;
        }

        public Builder weight(String weight){
            this.weight = weight;
            return this;
        }

        public Builder height(String height){
            this.height = height;
            return this;
        }

    }

    @Override
    public String toString() {
        return "{\"name\":\"" + name + "\",\"age\":\"" + age
                + "\",\"weight\":\"" + weight + "\",\"height\":\"" + height
                + "\"}";
    }

}

声明内部类，Person的构造器对外隐藏，在内部类的创建Person的成员变量时，返回this，实现链式调用。
把自己学习设计模式的过程记成笔记，方便自己随时查看，如有错误，欢迎指出，谢谢！