安装电脑思考到了Java设计模式：建造者模式

目录

• 定义
• 意图
• 主要解决问题
• 何时使用
• 优缺点
• 结构
• 组装电脑的例子

定义

建造者模式是对象的创建型模式，可以将一个产品的内部表象与产品的生成过程分割开来，从而可以使一个建造过程生成具有不同的内部表象的产品对象

建造者模式将产品的结构和产品的零件建造过程对客户端隐藏起来，把对建造过程进行指挥的责任和具体建造者零件的责任分割开来，达到责任划分和封装的目的

意图

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

主要解决问题

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

何时使用

一些基本部件不会变，而其组合经常变化的时候

优缺点

优点：

• 建造者独立，易扩展
• 便于控制细节风险

缺点：

• 产品必须有共同点，范围有限制
• 如果内部变化复杂，会有很多的建造类

结构

涉及的角色：

• 抽象建造者（Builder）角色：给出一个抽象接口，用来规范产品对象的各个组成成分的建造，一般来说，产品所包含的零件数目和建造方法的数目相等，换而言之，有多少个零件，就有多少相应的建造方法
• 具体建造者（ConcreteBuilder）角色：实现抽象建造者所声明的接口，给出一步步的完成创建产品实例的操作；在建造过程完成后，提供产品的实例
• 导演者（Director）角色：担任这个角色的类调用具体建造者角色来创建产品对象，导演者角色并没有产品类的具体知识，真正拥有产品类的具体知识的是具体建造者角色
• 产品（Product）角色：产品便是建造中的复杂对象，一般来说，一个系统中会有多于一个的产品类，而且这些产品类并不一定有共同的接口，而完全可以是不相关的

一般来说，每有一个产品类，就有一个相应的具体建造者类，这些产品应当有一样数目的零件，而每有一个零件，就相应的在所有的建造者角色中有一个建造方法

源码如下：

public interface Builder {

    /** 产品零件构造方法 */
    void buildPart1();

    /** 产品零件构造方法 */
    void buildPart2();

    /** 产品返还方法 */
    Product retrieveResult();
}

public class ConcreteBuilder implements Builder {

    private Product product = new Product();

    /** 产品零件构造方法 */
    @Override
    public void buildPart1() {
        //建造产品的第一个零件
    }

    /** 产品零件构造方法 */
    @Override
    public void buildPart2() {
        //建造产品的第二个零件
    }

    /** 产品返还方法 */
    @Override
    public Product retrieveResult() {
        return product;
    }
}

public class Director {
    private Builder builder;

    /**
     * 产品构造方法，负责调用各个零件构造方法
     */
    public void construct() {
        builder = new ConcreteBuilder();
        builder.buildPart1();
        builder.buildPart2();
        builder.retrieveResult();
    }
}

public class Product {
}

组装电脑的例子

电脑的组装有内存、主板、cpu、机箱等，可以按照不同的步骤进行组装

电脑类：

public class Compute {

    /** cpu */
    private String cpu;

    /** 主板 */
    private String board;

    /** 内存 */
    private String memory;

    /** 机箱 */
    private String crate;

    public String getCpu() {
        return cpu;
    }

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

    public String getBoard() {
        return board;
    }

    public void setBoard(String board) {
        this.board = board;
    }

    public String getMemory() {
        return memory;
    }

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

    public String getCrate() {
        return crate;
    }

    public void setCrate(String crate) {
        this.crate = crate;
    }

    @Override
    public String toString() {
        return "Compute{" +
                "cpu='" + cpu + '\'' +
                ", board='" + board + '\'' +
                ", memory='" + memory + '\'' +
                ", crate='" + crate + '\'' +
                '}';
    }
}

抽象建造者角色，抽象出组装电脑的步骤：

public interface ComputeBuilder {

    /** 组装CPU */
    void buildCpu();

    /** 组装主板 */
    void buildBoard();

    /** 组装内存 */
    void buildMemory();

    /** 组装机箱 */
    void buildCrate();

    /** 组装完成，返回一台电脑 */
    Compute getCompute();
}

具体建造者角色，组装各个零件的操作：

public class ConcreteComputeBuilder implements ComputeBuilder {

    private Compute compute = new Compute();

    @Override
    public void buildCpu() {
        System.out.println("组装cpu");
        compute.setCpu("组装cpu");
    }

    @Override
    public void buildBoard() {
        System.out.println("组装主板");
        compute.setBoard("组装主板");
    }

    @Override
    public void buildMemory() {
        System.out.println("安装内存条");
        compute.setMemory("安装内存条");
    }

    @Override
    public void buildCrate() {
        System.out.println("安装机箱");
        compute.setCrate("安装机箱");
    }

    @Override
    public Compute getCompute() {
        return compute;
    }
}

开始组装：

public class ComputeDirector {

    private ComputeBuilder builder;

    public void assemblyCompute() {
        builder = new ConcreteComputeBuilder();
        builder.buildCpu();
        builder.buildBoard();
        builder.buildMemory();
        builder.buildCrate();
        System.out.println(builder.getCompute());
    }
}

测试类：

public class Client {
    public static void main(String[] args) {
        ComputeDirector director = new ComputeDirector();
        director.assemblyCompute();
    }
}