设计模式-建造者模式

建造者模式

W:将一个复杂的对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示，属于创建型模式

w:创建者模式隐藏了复杂对象的创建过程，它把复杂对象的创建过程加以抽象，通过子类继承或者重载的方式，动态的创建具有复合属性的对象。

参照：https://zhuanlan.zhihu.com/p/58093669

案例：

假设现在产品是一台电脑包括 必须品：主板、CPU 、内存、电源 ，可选品：屏幕、鼠标、键盘

// DIY一台电脑，内部维护一个静态类，最终调用静态类的builder方法，返回我们DIY的各种参数
public class DIYComputer {
    private String mainboard;
    private String cpu;
    private String ram;
    private String power;
    private String screen;
    private String mouse;
    private String keyboard;

    private DIYComputer(DIYComputerBuilder builder){
        this.mainboard = builder.mainboard;
        this.cpu = builder.cpu;
        this.ram = builder.ram;
        this.power = builder.power;
        this.screen = builder.screen;
        this.mouse = builder.mouse;
        this.keyboard = builder.keyboard;
    }

    @Override
    public String toString() {
        return "DIYComputer{" +
                "mainboard='" + mainboard + '\'' +
                ", cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", power='" + power + '\'' +
                ", screen='" + screen + '\'' +
                ", mouse='" + mouse + '\'' +
                ", keyboard='" + keyboard + '\'' +
                '}';
    }

    public static class DIYComputerBuilder {
        private String mainboard;
        private String cpu;
        private String ram;
        private String power;
        private String screen;
        private String mouse;
        private String keyboard;

        public DIYComputerBuilder(String mainboard, String cpu, String ram, String power){
            this.mainboard = mainboard;
            this.cpu = cpu;
            this.ram = ram;
            this.power = power;
        }

        public DIYComputerBuilder setScreen(String screen) {
            this.screen = screen;
            return this;
        }

        public DIYComputerBuilder setMouse(String mouse) {
            this.mouse = mouse;
            return this;
        }

        public DIYComputerBuilder setKeyBoard(String keyboard){
            this.keyboard = keyboard;
            return this;
        }

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

    }

}

调用：

DIYComputer computer= new DIYComputer.
                DIYComputerBuilder("hp", "i10", "1M", "20W").
                setMouse("mac mouse").build();
        System.out.println(computer);

传统Builder模式

UML:

还是按照上述案例

// 产品 product

public class Computer {
    // 必须品：主板、CPU 、内存、电源 ，可选品：屏幕、鼠标、键盘
    private String mainboard;
    private String cpu;
    private String ram;
    private String power;
    private String screen;
    private String mouse;
    private String keyboard;

    public Computer(String mainboard,String cpu, String ram,String power) {
        this.mainboard = mainboard;
        this.cpu = cpu;
        this.ram = ram;
        this.power = power;
    }

    public String getScreen() {
        return screen;
    }

    public void setScreen(String screen) {
        this.screen = screen;
    }

    public String getMouse() {
        return mouse;
    }

    public void setMouse(String mouse) {
        this.mouse = mouse;
    }

    public String getKeyboard() {
        return keyboard;
    }

    public void setKeyboard(String keyboard) {
        this.keyboard = keyboard;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "mainboard='" + mainboard + '\'' +
                ", cpu='" + cpu + '\'' +
                ", ram='" + ram + '\'' +
                ", power='" + power + '\'' +
                ", screen='" + screen + '\'' +
                ", mouse='" + mouse + '\'' +
                ", keyboard='" + keyboard + '\'' +
                '}';
    }
}

// 抽象 builder

public abstract class ComputerBuilder {
    public abstract void setKeyboard();
    public abstract void setScreen();
    public abstract void setMouse();
    public abstract Computer getComputer();
}

// 具体实现

public class MacComputerBuilder extends ComputerBuilder{
    private Computer computer;
    public MacComputerBuilder(String mainboard,String cpu,String ram,String power){
        computer = new Computer(mainboard,cpu,ram,power);
    }

    @Override
    public void setKeyboard() {
        computer.setKeyboard("mac 键盘");
    }

    @Override
    public void setScreen() {
        computer.setScreen("mac 屏幕");
    }

    @Override
    public void setMouse() {
        computer.setMouse("mac mouse");
    }

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


public class HpComputerBuilder extends ComputerBuilder{
    private Computer computer;
    public HpComputerBuilder(String mainboard, String cpu, String ram, String power){
        computer = new Computer(mainboard,cpu,ram,power);
    }

    @Override
    public void setKeyboard() {
        computer.setKeyboard("hp 键盘");
    }

    @Override
    public void setScreen() {
        computer.setScreen("hp 屏幕");
    }

    @Override
    public void setMouse() {
        computer.setMouse("hp mouse");
    }

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

// director 指导最终产品构建

public class Director {
    public void buyAllComputer(ComputerBuilder computerBuilder){
        computerBuilder.setKeyboard();
        computerBuilder.setMouse();
        computerBuilder.setScreen();
    }

    public void buykeyboardComputer(ComputerBuilder computerBuilder){
        computerBuilder.setKeyboard();
    }
}

// 调用

        MacComputerBuilder macComputerBuilder = new MacComputerBuilder("mac Mainboard", "M1", "100M", "200W");
        HpComputerBuilder hpComputerBuilder = new HpComputerBuilder("hp Mainboard", "i10", "500M", "300W");
        Director director = new Director();
        // 只需要一个键盘
        director.buykeyboardComputer(macComputerBuilder);
        // 所有的都需要
        director.buyAllComputer(hpComputerBuilder);
        Computer computer = macComputerBuilder.getComputer();
        Computer computerhp = hpComputerBuilder.getComputer();
        System.out.println(computer);
        System.out.println(computerhp);

Q: 建造者模式 和 工厂模式有什么区别

建造者模式重视建造过程，工厂模式重视建造结果。