建造者模式

 1）作用：将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

2）关键点:

　　1.Product(具体产品):表示被构造的复杂对象。

　　2.Builder(抽象构建产品):为构建一个产品对象的各个部件指定抽象接口。

　　3.BuilderImpl(抽象构建的具体实现)：实现Builder的接口以构造和装配该产品的各个部件，定义并明确它所创建的表示。

　　4.Director(建造者）：构造一个使用Builder接口的对象。

3）优点：

　　1.易于解耦：将产品本身与产品创建过程进行解耦，可以使用相同的创建过程来得到不同的产品，也就是说细节依赖抽象。

　　2.易于精确控制对象的创建：将复杂的产品创建步骤分解在不同方法中，使得创建过程更加清晰。

　　3.易于拓展：增加新的具体的建造者无需修改原有类库，易于拓展，符合开闭原则。

4）缺点：1.建造者所创建的产品一般具有较多的共同点，其组成部分相似；如果产品之间差异性很大，则不适合使用建造者模式，因此其使用范围受到一定限制。

　　　　　2.如果产品内部变化复杂，可能会导致需要定义很多具体的建造者来实现这种变换，导致系统很庞大。

5）应用场景：1.需要生产的产品对象有复杂的内部结构，这些产品对象具有共性；

　　　　　　2.隔离复杂对象的创建和使用，并使得相同的创建过程可以创建不同的产品。

package com.ual.builder;
//具体产品
public class Computer {
    private String mainBoard;//主板
    private String  hardDisk;//硬盘
    private  String cpu;//cpu

    public String getMainBoard() {
        return mainBoard;
    }

    public void setMainBoard(String mainBoard) {
        this.mainBoard = mainBoard;
    }

    public String getHardDisk() {
        return hardDisk;
    }

    public void setHardDisk(String hardDisk) {
        this.hardDisk = hardDisk;
    }

    public String getCpu() {
        return cpu;
    }

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

    @Override
    public String toString() {
        return "Computer{" +
                "mainBoard='" + mainBoard + '\'' +
                ", hardDisk='" + hardDisk + '\'' +
                ", cpu='" + cpu + '\'' +
                '}';
    }
}

package com.ual.builder;

public interface buider {
    //构建主板
    public void builderMainBoard();
    //构建主板
    public void builderHD();
    //构建cpu
    public void builderCpu();
    //生成产品
    public Computer builderComputer();
}

package com.ual.builder;
//具体的构建
public class ComputerBuilder implements buider {
    private Computer c=new Computer();
    @Override
    public void builderMainBoard() {
        c.setMainBoard("戴尔");
    }

    @Override
    public void builderHD() {
        c.setMainBoard("希捷");
    }

    @Override
    public void builderCpu() {
        c.setCpu("intel");
    }

    @Override
    public Computer builderComputer() {
        return c ;
    }
}

package com.ual.builder;
//具体的构建
public class ComputerBuilder1 implements buider {
    private Computer c=new Computer();
    @Override
    public void builderMainBoard() {
        c.setMainBoard("华硕");
    }

    @Override
    public void builderHD() {
        c.setMainBoard("金士顿");
    }

    @Override
    public void builderCpu() {
        c.setCpu("AMD");
    }

    @Override
    public Computer builderComputer() {
        return c ;
    }
}

package com.ual.builder;


//建造者
public class Director {
        public  static  Computer constructorComputer(buider b){//这里传入的是抽象接口声明
            b.builderMainBoard();
            b.builderHD();
            b.builderCpu();
            return  b.builderComputer();
        }
}

package com.ual.builder;

public class Test {
    @org.junit.Test
    public void test(){
        Computer computer = Director.constructorComputer(new ComputerBuilder());
        System.out.println(computer);
        Computer computer1 = Director.constructorComputer(new ComputerBuilder1());
        System.out.println(computer1);
    }
}