建造者模式

建造者模式使用的也是比较多的设计模式，其他创建型及23种设计模式点这。其实这个例子不好写，因为建造者模式一般在对象属性比较多时，我这又懒所以只用了三个。我们先写一下Builder的形：

public class Computer {
    private String cpu;
    private String screen;
    private String disk;

    private Computer() {
    }

    @Override
    public String toString() {
        return "cpu:" + cpu + " disk:" + disk + " screen:" + screen;
    }

    static class Builder {
        private Computer computer = new Computer();

        public Builder setCpu(String cpu) {
            computer.cpu = cpu;
            return this;
        }

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

        public Builder setDisk(String disk) {
            computer.disk = disk;
            return this;
        }

        public Computer getComputer() {
            return computer;
        }
    }

    public static void main(String[] args) {
        Computer computer1 = new Builder().setCpu("intel i7").setDisk("512M SSD")
                .setScreen("AOC").getComputer();
        Computer computer2 = new Builder().setCpu("AMD Ryzen7").setDisk("1T SSD")
                .setScreen("SAMSUNG").getComputer();
        System.out.println(computer1);
        System.out.println(computer2);
    }
}
输出：
cpu:intel i7 disk:512M SSD screen:AOC
cpu:AMD Ryzen7 disk:1T SSD screen:SAMSUNG

为啥叫Builder的形呢， 因为跟直接set属性唯一的区别就是可以不停的点点点。下面就是第二种，也是像okhttp和google源码里的形式：

public class Computer {
    private String cpu;
    private String screen;
    private String disk;

    private Computer(Builder builder) {//这里用了一个构造方法，保证了程序过程无关。
        cpu = builder.cpu;
        screen = builder.screen;
        disk = builder.disk;
    }

    @Override
    public String toString() {
        return "cpu:" + cpu + " disk:" + disk + " screen:" + screen;
    }

    static class Builder {
        private String cpu;//这里多了相同三个属性，其实不同时Builder这种封装才有优势。
        private String screen;
        private String disk;

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

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

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

        public Computer build() {//可以发现没build之前没有computer对象
            return new Computer(this);
        }
    }

//    public static class BuilderDirector {
//        public static Builder BuilderDirectorA() {
//            Builder builderA = new Builder().setCpu("intel i7")
//                    .setDisk("512M SSD").setScreen("AOC");
//            return builderA;
//        }
//    }

    public static void main(String[] args) {
        Computer computer1 = new Builder().setCpu("intel i7").setDisk("512M SSD")
                .setScreen("AOC").build();
        Computer computer2 = new Builder().setCpu("AMD Ryzen7").setDisk("1T SSD")
                .setScreen("SAMSUNG").build();
        System.out.println(computer1);
        System.out.println(computer2);

//        Computer computerB = BuilderDirector.BuilderDirectorA()
//        .setCpu("intel i5").build();
//        System.out.println(computer3);
    }
}
输出：同上

先说一下这个的好处：
1.他的封装可以降低耦合。
2.用一个构造器可以保证所有生成的类遵循同一个构造顺序，即过程无关。
3.不用写大量的重载构造方法，也用点点点取代set方式。

最后，其实我觉得跟建造者模式没多大关系的导演者。当然在builderA常用时，我们可以封装成一个方法来获取这个Builder并进行简单修改获得我们要的ComputerB。