设计模式之建造者模式

设计模式之建造者模式

什么时候用建造者模式：

• 创建一些复杂的对象时，这些对象的内部组成构件间的建造顺序是稳定的，但是对象的内部组成构件面临着复杂的变化。

• 要创建的复杂对象的算法，独立于该对象的组成部分，也独立于组成部分的装配方法时。

• 我们需要建一个复杂的产品例如一部手机，而且这个复杂产品的建造需要处理一个问题即装配这些子组件。

开发中的应用场景：

• Stringbuilder中的append方法

• sql中PreStatement

---

建造者模式怎么用

建造者模式通常包括的角色：

1. builder：给出一个抽象接口，以规范产品对象的各个组成成分的建造。这个接口规定要实现复杂对象的哪些部分的创建，并不涉及具体的对象部件的创建。
2. ConcreteBuilder：实现Builder接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
3. Director：给出一个抽象接口，这个接口规定组装的方法。
4. ConcreteDirector：实现Director接口，针对不同的商业逻辑，具体化复杂对象的各部分的创建。 在建造过程完成后，提供产品的实例。
5. Product：要创建的复杂对象。

---

建造者模式的结构图：

---

code：

package Builder;

//创建一个phone类
public class Phone {
    private Battery battery;// 电池
    private Motherboard motherboard;// 主板
    public Battery getBattery() {
        return battery;
    }
    public void setBattery(Battery battery) {
        this.battery = battery;
    }
    public Motherboard getMotherboard() {
        return motherboard;
    }
    public void setMotherboard(Motherboard motherboard) {
        this.motherboard = motherboard;
    }

}

class Battery {
    private String name;

    public Battery(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

class Motherboard {
    private String name;

    public Motherboard(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

package Builder;

//构建子组建
public interface PhoneBuilder {
    Battery buildebattery();// 电池

    Motherboard buildemotherboard();// 主板
}

package Builder;

//装配
public interface PhoneDirector {
    Phone DirectPhone();// 组装phone
}

package Builder;

public class huaweiBuilder implements PhoneBuilder {

    @Override
    public Battery buildebattery() {
        System.out.println("构建电池");
        return new Battery("huawei电池");//这里可以和工厂模式结合
    }

    @Override
    public Motherboard buildemotherboard() {
        System.out.println("构建主板");
        return new Motherboard("huawei主板");
    }

}

package Builder;

public class huaweiDirector implements PhoneDirector {

    public huaweiDirector(huaweiBuilder buider) {
        this.buider = buider;
    }
    private huaweiBuilder buider;

    public huaweiBuilder getBuider() {
        return buider;
    }

    public void setBuider(huaweiBuilder buider) {
        this.buider = buider;
    }

    @Override
    public Phone DirectPhone() {
        Battery battery = buider.buildebattery();
        Motherboard motherboard = buider.buildemotherboard();
        Phone phone = new Phone();
        phone.setBattery(battery);
        phone.setMotherboard(motherboard);
        return phone;
    }

}

package Builder;

public class Client {
    public static void main(String[] args) {
        huaweiBuilder buider = new huaweiBuilder();
        huaweiDirector director = new huaweiDirector(buider);
        Phone phone = director.DirectPhone();
        System.out.println(phone.getBattery().getName());
        System.out.println(phone.getMotherboard().getName());
    }
}

---

为什么要用建造者模式

使用建造者模式的好处：

1.使用建造者模式可以使客户端不必知道产品内部组成的细节。

2.具体的建造者类之间是相互独立的，对系统的扩展非常有利。

3.由于具体的建造者是独立的，因此可以对建造过程逐步细化，而不对其他的模块产生任何影响。