GOF23设计模式（创建型模式）~建造者模式~ 代码分析式讲解！！

使用场景：

我们要建造一个复杂的产品,比如生产一辆汽车、一部手机，这都是由很多零部件组成的，这时候就需要用到我们的建造者模式，将每个零部件分别生产，然后再装配~~

---

以下，我将以一个手机的生产过程为实例，这里将手机分为三部分零件， screen屏幕、battery电池、speaker扬声器：

1. 首先创建Screen、Battery、Speaker这三个原件类，并根据这三个类创建手机类Phone、

package 三_创造者模式;
/**
 * 手机的组成
 */
public class Phone {
    Screen screen;//屏幕
    Battery battery;//电池
    Speaker speaker;//扬声器

    public Phone() {}

    public void setScreen(Screen screen) {
        this.screen = screen;
    }
    public void setBattery(Battery battery) {
        this.battery = battery;
    }
    public void setSpeaker(Speaker speaker) {
        this.speaker = speaker;
    }
    public Screen getScreen() {
        return screen;
    }
    public Battery getBattery() {
        return battery;
    }
    public Speaker getSpeaker() {
        return speaker;
    }
}

//屏幕
class Screen {
    String name;

    public Screen(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

//电池
class Battery {
    String name;

    public Battery(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

//扬声器
class Speaker {
    String name;

    public Speaker(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

    2. 创建两个接口，一个是用来生产手机三组件的PhoneBuilder，一个是用来装配这三个组件的PhoneDirector

package 三_创造者模式;
/**
 * 构建手机子组件
 */
public interface PhoneBuilder {
    Screen screenBuilder();
    Battery batteryBuilder();
    Speaker speakerBuilder();
}

package 三_创造者模式;

/**
 * 组装手机子组件
 */
public interface PhoneDirector {
    Phone directorPhone();
}

   3. 根据上述两个接口构造相应的实现类，这里以苹果手机为例，创建一个iphoneBuilder用来生产苹果手机的的三大组件，再创建一个iphoneDirector用来装配苹果手机这三个组件

package 三_创造者模式;

/**
 * 苹果手机组件的构造
 */
public class iphoneBuilder implements PhoneBuilder {

    @Override
    public Screen screenBuilder() {
        return new Screen("原彩显示lcd屏");
    }

    @Override
    public Battery batteryBuilder() {
        return new Battery("苹果电池");
    }

    @Override
    public Speaker speakerBuilder() {
        return new Speaker("双扬声器");
    }
}

package 三_创造者模式;

/**
 * 装配苹果手机组件
 */
public class iphoneDirector implements PhoneDirector {
    private iphoneBuilder iphonebuilder;//苹果手机组件构造

    public iphoneDirector(iphoneBuilder iphonebuilder) {
        this.iphonebuilder = iphonebuilder;
    }

    @Override
    public Phone directorPhone() {
        Battery battery = iphonebuilder.batteryBuilder();
        Screen screen = iphonebuilder.screenBuilder();
        Speaker speaker = iphonebuilder.speakerBuilder();
        //装配手机对象
        Phone iphone = new Phone();
        iphone.setBattery(battery);
        iphone.setScreen(screen);
        iphone.setSpeaker(speaker);
        return iphone;
    }
}

   4. 最后我们主函数里面进行测试，我们实例化出一个苹果手机对象

package 三_创造者模式;

public class client {
    public static void main(String[] args) {
        PhoneDirector director = new iphoneDirector(new iphoneBuilder());
        Phone phone = director.directorPhone();
        System.out.println(phone.getBattery().getName());
        System.out.println(phone.getScreen().getName());
        System.out.println(phone.getSpeaker().getName());
    }
}

运行结果:

---

总结：

• 分离了对象子组件的单独构造（由 Builder来负责）和装配（由 Director负责）.从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用。
• 由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做岀不同的对象；相同的构建器，不同的装配顺序也可以做岀不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。