Java 设计模式之建造者模式

建造者模式（Builder）:建造的过程是稳定的。

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。
如果需要将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示的意图时，我们就需要建造者模式，如果我们用了建造者模式，那么用户就只需指定需要建造的类型就可以得到他们，而具体的建造的过程和细节就不需要知道了。

Builder:是为创建一个Product对象的各个部件指定的抽象的接口。
ConcreteBuilder:是具体的建造者，实现Builder接口，构造和装配各个部件。
product:具体的产品
Director:根据需求构建产品对象。他是构建一个使用Builder接口的对象。
建造者模式的使用范围：主要是用于创建一些复杂的对象，这些对象内部构建间的建造顺序通常是稳定的，但对象内部的构建通常面临着复杂的变化。
建造者模式隐藏了该产品是如何组装的，所以如果需要改变一个产品的内部表示，只需要在定义一个具体的建造者就可以了。

比如组装一台电脑。
Builder接口：

public interface Builder {
    //组装主板
    void constructBoard();
    //组装显卡
    void constructCard();
    //组装Cpu
    void constructCpu();
    //组装硬盘
    void constructDisk();
    //返回电脑
    Computer constructComputer();
}

建造者：

public class Constructor implements Builder {
    private Computer computer;
    public Constructor(){
        computer = new Computer();
    }
    @Override
    public void constructBoard() {
        computer.setBoard("h61主板");
        System.out.println("正在组装h61主板");
    }

    @Override
    public void constructCard() {
        computer.setCard("技嘉");
        System.out.println("正在组装技嘉显卡");
    }

    @Override
    public void constructCpu() {
        computer.setCpu("英特尔i7");
        System.out.println("正在组装英特尔i7cpu");
    }

    @Override
    public void constructDisk() {
        computer.setDisk("500G硬盘");
        System.out.println("正在组装500G硬盘");
    }




    @Override
    public Computer constructComputer() {
        return computer;
    }
}

电脑组成成分：

public class Computer {
    private String board;
    private String card;
    private String cpu;
    private String disk;

    public String getBoard() {
        return board;
    }

    public void setBoard(String board) {
        this.board = board;
    }

    public String getCard() {
        return card;
    }

    public void setCard(String card) {
        this.card = card;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public String getDisk() {
        return disk;
    }

    public void setDisk(String disk) {
        this.disk = disk;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "board='" + board + '\'' +
                ", card='" + card + '\'' +
                ", cpu='" + cpu + '\'' +
                ", disk='" + disk + '\'' +
                '}';
    }
}

Director:

public class Director {
    private Builder builder;
    public Director(Builder builder){
        this.builder = builder;
    }
    public Computer DirectConstructor(){
        builder.constructBoard();
        builder.constructCard();
        builder.constructCpu();
        builder.constructDisk();
        return builder.constructComputer();
    }
}

客户端：

public class Client {
    public static void main(String[] args) {
        Builder builder = new Constructor();
        Director director = new Director(builder);
        Computer computer = director.DirectConstructor();
        System.out.println(computer.toString());

    }
}

正在组装h61主板
正在组装技嘉显卡
正在组装英特尔i7cpu
正在组装500G硬盘
Computer{board='h61主板', card='技嘉', cpu='英特尔i7', disk='500G硬盘'}

建造者模式是在当创建复杂对象的算法应该独立于该对象的组成部分以及他们的装配方式时适用的模式。