3、设计模式之建造者模式

开始之前

本章节是一个系列，里面用的的代码实例都是连贯的。在实现某一种设计模式时，为了较少代码篇幅，前面博客出现model类（仅限公用的model类，比如compute、CPU、Mem、Disk等纯对象类）不会重复出现，读者在阅读某一篇博客时，如果发现突然出现了一个新的model类，在本片博客中没有其定义，可以往前面的博客翻一下！

最后，当本系列更新完成后，我会整个的代码完整贴出来，提供下载链接！

概述

建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

意图

将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

主要解决

主要解决在软件系统中，有时候面临着"一个复杂对象"的创建工作，其通常由各个部分的子对象用一定的算法构成；由于需求的变化，这个复杂对象的各个部分经常面临着剧烈的变化，但是将它们组合在一起的算法却相对稳定。

优点：

• 分离构建过程和表示，使得构建过程更加灵活，可以构建不同的表示。
• 可以更好地控制构建过程，隐藏具体构建细节。
• 代码复用性高，可以在不同的构建过程中重复使用相同的建造者。

缺点：

• 如果产品的属性较少，建造者模式可能会导致代码冗余。
• 建造者模式增加了系统的类和对象数量。

使用场景

1、需要生成的对象具有复杂的内部结构。
2、需要生成的对象内部属性本身相互依赖。

建造者模式在创建复杂对象时非常有用，特别是当对象的构建过程涉及多个步骤或参数时。它可以提供更好的灵活性和可维护性，同时使得代码更加清晰可读。

注意事项

与工厂模式的区别是：建造者模式更加关注与零件装配的顺序。

代码实现

public abstract class Compute implements Serializable {

    protected Power power;

    protected CPU cpu;

    protected Mem mem;

    protected Disk disk;

    protected abstract String getName();

    public void cpu(CPU cpu) {
        this.cpu = cpu;
    }

    public void disk(Disk disk){
        this.disk = disk;
    }

    public void mem(Mem mem){
        this.mem = mem;
    }

    public void power(Power power){
        this.power = power;
    }

    public void run(){
        System.out.println("运行电脑 " + getName());
        power.powerOn();
        cpu.run();
        mem.input();
        mem.output();
        disk.read();
        disk.write();
        power.powerOff();
        System.out.println("关闭电脑 " + getName());
    }
}

public class XiaomiCompute extends Compute{

    @Override
    protected String getName() {
        return "xiaomi compute";
    }
}

public abstract class CPU implements Serializable {

    protected abstract String getName();

    public void run(){
        System.out.println(getName() +" running!");
    }
}

public class XiaomiCpu extends CPU{

    @Override
    protected String getName() {
        return "xiaomi cpu";
    }
}

public abstract class Disk implements Serializable {
    protected abstract String getName();

    public void write(){
        System.out.println(getName()+" write");
    }

    public void read(){
        System.out.println(getName()+" read");
    }
}

public class XiaomiDisk extends Disk{
    @Override
    protected String getName() {
        return "xiaomi disk";
    }
}

public abstract class Mem implements Serializable {

    protected abstract String getName();
    public void input(){
        System.out.println(getName()+" input");
    }

    public void output(){
        System.out.println(getName()+" output");
    }
}

public class XiaomiMem extends Mem{

    @Override
    protected String getName() {
        return "xiaomi mem";
    }
}

public abstract class Power {

    /**
     * 电压
     * @return
     */
    protected abstract int voltage();

    public void powerOn() {
        System.out.println(voltage()+"V电压 ON");
    }

    public void powerOff() {
        System.out.println(voltage()+"V电压 OFF");
    }
}

/**
* 220V 电压
*/
public class V220 extends Power{
    @Override
    protected int voltage() {
        return 220;
    }

}

public class ComputeBuilder {

    private CPU cpu;
    private Mem mem;

    private Disk disk;

    private Power power;

    public ComputeBuilder cpu(CPU cpu){
        this.cpu = cpu;
        return this;
    }

    public ComputeBuilder mem(Mem mem){
        this.mem = mem;
        return this;
    }

    public ComputeBuilder disk(Disk disk){
        this.disk = disk;
        return this;
    }

    public ComputeBuilder power(Power power){
        this.power = power;
        return this;
    }

    public Compute build(){
        Compute compute = new XiaomiCompute();
        compute.cpu(cpu);
        compute.mem(mem);
        compute.disk(disk);
        compute.power(power);
        return compute;
    }
}

public class Client {
    public static void main(String[] args) {
        ComputeBuilder computeBuilder = new ComputeBuilder();
        Compute compute = computeBuilder
                .power(new V220())
                .disk(new XiaomiDisk())
                .cpu(new XiaomiCpu())
                .mem(new XiaomiMem())
                .build();
        compute.run();
    }
}