建造者模式

所创建的产品一般有较多的共同点。

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

复杂产品的创建步骤分解在不同的方法中，使得构造过程更加清晰

对象的创建和它的表示分离。

使用者不知道对象的创建过过程和细节的情况下就可以直接创建复杂的对象。

适合一个具体较多的零件的产品的创建模式，组装好一个完整产品

具体的创造者类之间是相互独立的，有利于程序扩展，

新增的建造者无需修改原有类库的代码，符合开闭原则。

创造者模式测试1、

 

/**
 * 具体的产品phone
 */
public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;

    public String getCpu() {
        return cpu;
    }

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

    public String getScreen() {
        return screen;
    }

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

    public String getMemory() {
        return memory;
    }

    public Phone setMemory(String memory) {
        this.memory = memory;
        return this;
    }

    public String getMainboard() {
        return mainboard;
    }

    public Phone setMainboard(String mainboard) {
        this.mainboard = mainboard;
        return this;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                '}';
    }
}
/**
 * 抽象的建造者
 * 手机的多个配件
 */
public abstract class PhoneBuilder {
    Phone phone = new Phone();
    public abstract void setCpu();
    public abstract void setScreen();
    public abstract void setMemory();
    public abstract void setMainboard();

    public Phone getPhone(){
        return phone;
    }
}
/**
 * 具体的建造者
 * 手机的多个配件
 */
public class ApplePhoneBuilder extends  PhoneBuilder {
    @Override
    public void setCpu() {
        phone.setCpu("apple cpu");
    }

    @Override
    public void setScreen() {
        phone.setScreen("apple screen");
    }

    @Override
    public void setMemory() {
        phone.setMemory("apple memory");
    }

    @Override
    public void setMainboard() {
        phone.setMainboard("apple mainboard");
    }
}
/**
 * 指挥者
 * 手机配件组装成一部手机
 */
public class PhoneDirector {
    private PhoneBuilder phoneBuilder;
    public PhoneDirector(PhoneBuilder phoneBuilder){
        this.phoneBuilder = phoneBuilder;
    }
    public Phone phoneBuilder(){
        phoneBuilder.setCpu();
        phoneBuilder.setScreen();
        phoneBuilder.setMainboard();
        phoneBuilder.setMemory();
        return phoneBuilder.getPhone();
    }
}

创造者模式测试2、

使用链式组装

/**
 * 具体的产品phone
 */
public class Phone {
    private String cpu;
    private String screen;
    private String memory;
    private String mainboard;

    public String getCpu() {
        return cpu;
    }

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

    public String getScreen() {
        return screen;
    }

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

    public String getMemory() {
        return memory;
    }

    public Phone setMemory(String memory) {
        this.memory = memory;
        return this;
    }

    public String getMainboard() {
        return mainboard;
    }

    public Phone setMainboard(String mainboard) {
        this.mainboard = mainboard;
        return this;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "cpu='" + cpu + '\'' +
                ", screen='" + screen + '\'' +
                ", memory='" + memory + '\'' +
                ", mainboard='" + mainboard + '\'' +
                '}';
    }
}

/**
 * 抽象的建造者
 * 手机的多个配件。
 * 注意配件返回值是PhoneBuidler，可以不要指挥者Director，
 * 使用者直接直接链式组装成一部手机
 */
public abstract class PhoneBuidler {
    Phone phone = new Phone();
    public abstract PhoneBuidler setCpu(String cpu);
    public abstract PhoneBuidler setScreen(String screen);
    public abstract PhoneBuidler setMemory(String memory);
    public abstract PhoneBuidler setMainboard(String mainboard);

    public Phone getPhone(){
        return phone;
    }
}

/**
 * 具体的建造者
 * 手机的多个配件。
 * 注意配件返回值是PhoneBuidler，可以不要指挥者Director，
 * 使用者直接直接链式组装成一部手机
 */
public class ApplePhoneBuilder extends PhoneBuidler {

    @Override
    public PhoneBuidler setCpu(String cpu) {
        phone.setCpu(cpu);
        return this;
    }

    @Override
    public PhoneBuidler setScreen(String screen) {
        phone.setScreen(screen);
        return this;
    }

    @Override
    public PhoneBuidler setMemory(String memory) {
        phone.setMemory(memory);
        return this;
    }

    @Override
    public PhoneBuidler setMainboard(String mainboard) {
        phone.setMainboard(mainboard);
        return this;
    }

    @Override
    public Phone getPhone(){
        return phone;
    }
}

public class TestPhone {
    public static void main(String[] args) {
        ApplePhoneBuilder applePhoneBuilder = new ApplePhoneBuilder();
        applePhoneBuilder.setCpu("Intel")
                .setMemory("金山")
                .setMainboard("XX")
                .setScreen("YY");
        System.out.println(applePhoneBuilder.getPhone());
    }
}

 

 抽象工厂VS建造者模式

　　抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可。

　　建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。

　　如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车。