设计模式—建造者模式

文章目录

1. 1. 模式定义
2. 2. 模式结构
3. 3. UML图
4. 4. 代码实现
   1. 4.1. Builder.java
   2. 4.2. ApplePCBuilder.java
   3. 4.3. Computer.java
   4. 4.4. AppleComputer.java
   5. 4.5. Director.java
   6. 4.6. 测试类
5. 5. 模式分析
6. 6. 建造者模式的优点
7. 7. 建造者模式的缺点
8. 8. 总结

今天我们再来学习一种创建型模式，它就是建造者模式(Builder Pattern).

模式定义

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

建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。

模式结构

建造者模式包含如下角色：

Builder： 抽象建造者
ConcreteBuilder： 具体建造者
Director： 指挥者
Product： 产品角色

UML图

代码实现

Builder.java

public abstract class Builder {
    // 设置CPU核心数
    public abstract void buildCPU(int core);

    // 设置内存
    public abstract void buildRAM(int gb);

    // 设置操作系统
    public abstract void buildOs(String os);

    // 创建Computer
    public abstract Computer create();
}

ApplePCBuilder.java

public class ApplePCBuilder extends Builder {

    private Computer mComputer = new AppleComputer();

    @Override
    public void buildCPU(int core) {
        mComputer.setCPU(core);
    }

    @Override
    public void buildRAM(int gb) {
        mComputer.setRAM(gb);
    }

    @Override
    public void buildOs(String os) {
        mComputer.setOs(os);
    }

    @Override
    public Computer create() {
        return mComputer;
    }
}

Computer.java

public abstract class Computer {

    protected int mCpuCore = 1;
    protected int mRamSize = 0;
    protected String mOperationSystem = "Dos";

    // 设置CPU核心数
    public abstract void setCPU(int core);

    // 设置内存
    public abstract void setRAM(int gb);

    // 设置操作系统
    public abstract void setOs(String os);

    @Override
    public String toString() {
        return "Computer{" +
                "mCpuCore=" + mCpuCore +
                ", mRamSize=" + mRamSize +
                ", mOperationSystem='" + mOperationSystem + '\'' +                '}';    }}
                '
    }
}

AppleComputer.java

public class AppleComputer extends Computer {

    @Override
    public void setCPU(int core) {
        mCpuCore = core;
    }

    @Override
    public void setRAM(int gb) {
        mRamSize = gb;
    }

    @Override
    public void setOs(String os) {
        mOperationSystem = os;
    }
}

Director.java

public class Director {
    public Builder mBuilder = null;

    public Director(Builder builder) {
        mBuilder = builder;
    }

    public void construct(int cpu, int ram, String os) {
        mBuilder.buildCPU(cpu);
        mBuilder.buildRAM(ram);
        mBuilder.buildOs(os);
    }

}

测试类

public class MyClass {

    public static void main(String[] args) {
        Builder builder = new ApplePCBuilder();
        Director director =new Director(builder);
        director.construct(4,8,"Window7");
        System.out.println(builder.create().toString());
    }
}

模式分析

抽象建造者类中定义了产品的创建方法和返回方法;

建造者模式的结构中还引入了一个指挥者类Director，该类的作用主要有两个：一方面它隔离了客户与生产过程；另一方面它负责控制产品的生成过程。指挥者针对抽象建造者编程，客户端只需要知道具体建造者的类型，即可通过指挥者类调用建造者的相关方法，返回一个完整的产品对象

在客户端代码中，无须关心产品对象的具体组装过程，只需确定具体建造者的类型即可，建造者模式将复杂对象的构建与对象的表现分离开来，这样使得同样的构建过程可以创建出不同的表现。

建造者模式的优点

• 在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。

• 每一个具体建造者都相对独立，而与其他的具体建造者无关，因此可以很方便地替换具体建造者或增加新的具体建造者， 用户使用不同的具体建造者即可得到不同的产品对象 。

• 可以更加精细地控制产品的创建过程 ，将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。

• 增加新的具体建造者无须修改原有类库的代码，指挥者类针对抽象建造者类编程，系统扩展方便，符合“开闭原则”。

建造者模式的缺点

• 建造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

• 如果产品的内部变化复杂，可能会导致需要定义很多具体建造者类来实现这种变化，导致系统变得很庞大。

总结

建造者模式将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。建造者模式是一步一步创建一个复杂的对象，它允许用户只通过指定复杂对象的类型和内容就可以构建它们，用户不需要知道内部的具体构建细节。建造者模式属于对象创建型模式。

代码已经放到GitHub上了https://github.com/HJXANDHMR/DesignPattern。

欢迎大家关注我的微信公众号，我会不定期的分享些Android开发的技巧