坦克大战-建造者模式实现

科学的发展-只不过是读大自然写的代码

已于 2025-03-19 16:06:17 修改

阅读量601

点赞数

分类专栏：设计模式-坦克大战-java 文章标签：建造者模式

于 2019-03-21 12:58:32 首次发布

本文链接：https://blog.youkuaiyun.com/xie__jin__cheng/article/details/88712363

版权

设计模式-坦克大战-java 专栏收录该内容

56 篇文章

订阅专栏

1.概要

2.内容

目录：《一个实例讲完23种设计模式》

当前：创建者

需求：坦克大战

价值：控制一系列产品的创建步骤。让一系列函数相关。从需求的角度来将，这也起到了将需求分类的作用。

创建两种坦克

坦克类型	射程	速度
b70	70米	时/70公里
b50	50米	时/70公里

类图

要点

就是导演（导演）类桥接不同的创建者，决定了生成的坦克是不同的。无聊什么坦克都有两个创建步骤，创建速度，创建射程。

和抽象工厂的差别：抽象工厂是通过桥接不同的坦克工厂（抽象），创建出一系列不同的坦克部件（速度，射程）。

然后在用这些部件创造出坦克来。

虽然这里是用两种模式实现了相同的机能，但是通常应该是将两种模式结合起来用的，抽象工厂创建部件，然后又创建者来组装。后期我会在做一些模式的综合运用的示例。

代码（c++实现）

代码（js实现）

java实现

#include <iostream>
#include <string>
using namespace std;

class Function{
public:
    string mFunction;
    Function(string str){
        mFunction = str;
    }
    void exe(){
        cout<<mFunction<<"\n";
    }
};

//抽象层

class AbstractShot{
public:
    virtual void fun()=0;
};
class AbstractRun{
public:
    virtual void fun()=0;
};
class Tank{
public:
    AbstractShot* mPSort;
    AbstractRun* mPRun;
    virtual void fun(){
        mPSort->fun();
        mPRun->fun();
    }
};
class AbstractBuilder{
public:
    virtual void createShot(Tank& tank)=0;
    virtual void createRun(Tank& tank)=0;
};
//实施层
class B70Shot: public AbstractShot{
public:
    virtual void fun(){
        Function function("B70Shot:射程70");
        function.exe();
    }
};
class B50Shot: public AbstractShot{
public:
    virtual void fun(){
        Function function("B50Shot:射程50");
        function.exe();
    }
};
class B70Run: public AbstractRun{
public:
    virtual void fun(){
        Function function("B70Run：速度70");
        function.exe();
    }
};
class B50Run: public AbstractRun{
public:
    virtual void fun(){
        Function function("B50Run：速度50");
        function.exe();    
    }
};


class B70Builder:public AbstractBuilder{
public:
    virtual void createShot(Tank& tank){
        tank.mPSort = new B70Shot();
    }
    virtual void createRun(Tank& tank){
        tank.mPRun = new B50Run();
    }
};
class B50Builder:public AbstractBuilder{
public:
    virtual void createShot(Tank& tank){
        tank.mPSort = new B50Shot();
    }
    virtual void createRun(Tank& tank){
        tank.mPRun = new B50Run();
    }
};

class Direcctor{
public:
    AbstractBuilder& mBuilder;
    Direcctor(AbstractBuilder& b):mBuilder(b){    
    }
    Tank& construct(){
        Tank* tank = new Tank();
        mBuilder.createRun(*tank);
        mBuilder.createShot(*tank);
        return *tank;
    }
};
// 客户端
class Client{
public:
    static void main(){
        Direcctor d(*(new B70Builder()));
        Tank& t = d.construct();
        t.fun();
    }
};

//客户端调用
int main()
{
    Function function("建造者模式演示");
    function.exe();
    Client::main();

    //看代码不用考虑以下内容
    int cin_a;
    cin>>cin_a;
    return 0;
}

3.关联链接

4.关联知识

建造者模式（Builder Pattern）详解

1. 核心定义

建造者模式是一种分步构建复杂对象的创建型设计模式，其核心思想是将对象的构建过程（Builder）与最终表示（Product）解耦。通过独立的建造者类逐步组装对象的各个部分，最终由指导者（Director）控制构建流程。

2. 模式结构

产品（Product）
最终要构建的复杂对象，由多个子部件组成（如Computer包含CPU、内存、存储等）。
抽象建造者（Builder）
定义构建产品各子部件的抽象接口（如buildCPU(), buildMemory()），以及返回最终产品的getResult()方法。
具体建造者（ConcreteBuilder）
实现抽象建造者的接口，负责具体子部件的构建和组装（如GamingPCBuilder构建高性能电脑）。
指导者（Director）
按固定流程调用建造者的方法，控制产品的构建步骤（如先装CPU，再装内存，最后装存储）。

3. 代码示例（Java风格）

// 产品：电脑
class Computer {
    private String cpu;
    private String ram;
    private String storage;
    // 构造方法、getter/setter省略
}

// 抽象建造者
interface ComputerBuilder {
    void buildCPU(String cpu);
    void buildRAM(String ram);
    void buildStorage(String storage);
    Computer getResult();
}

// 具体建造者：游戏电脑建造者
class GamingPCBuilder implements ComputerBuilder {
    private Computer computer = new Computer();

    @Override
    public void buildCPU(String cpu) {
        computer.setCpu(cpu);
    }

    @Override
    public void buildRAM(String ram) {
        computer.setRam(ram);
    }

    @Override
    public void buildStorage(String storage) {
        computer.setStorage(storage);
    }

    @Override
    public Computer getResult() {
        return computer;
    }
}

// 指导者：组装流程
class ComputerDirector {
    public void constructComputer(ComputerBuilder builder) {
        builder.buildCPU("Intel i9");    // 步骤1：装CPU
        builder.buildRAM("32GB DDR5");   // 步骤2：装内存
        builder.buildStorage("2TB SSD"); // 步骤3：装存储
    }
}

// 客户端使用
public class Demo {
    public static void main(String[] args) {
        ComputerDirector director = new ComputerDirector();
        ComputerBuilder builder = new GamingPCBuilder();
        
        director.constructComputer(builder); // 按流程构建
        Computer gamingPC = builder.getResult(); // 获取最终产品
    }
}

4. 关键优势

灵活构建：允许通过不同建造者（如OfficePCBuilder）创建不同产品，或动态调整构建步骤。
封装细节：客户端无需知道对象内部如何组装，只需调用建造者接口。
不可变对象：可在getResult()中返回深拷贝或冻结对象，确保线程安全。

5. 典型应用场景

复杂对象配置
如配置服务器（选择操作系统、数据库、安全策略等）。
动态生成代码/UI
如根据用户输入生成SQL语句或动态表单界面。
资源池初始化
如数据库连接池的逐步初始化（设置连接数、超时时间等参数）。
链式调用（Fluent Interface）
如Java的StringBuilder或Lombok的@Builder注解，简化对象创建。

6. 与其他模式对比

模式	核心目标	适用场景
建造者模式	分步构建复杂对象	对象需要多步骤配置或组合部件
工厂模式	创建单个对象（通过子类决定类型）	根据类型参数直接创建对象
抽象工厂	创建产品族（一组相关产品）	跨平台/主题切换产品族（如UI组件）

7. 变体：链式调用（Fluent Builder）

在Java/C#等语言中，可通过返回this实现链式调用，提升代码可读性：

class PizzaBuilder {
    private Pizza pizza = new Pizza();

    public PizzaBuilder addCheese() {
        pizza.setCheese(true);
        return this; // 返回自身以支持链式调用
    }

    public PizzaBuilder addPepperoni() {
        pizza.setPepperoni(true);
        return this;
    }

    public Pizza build() {
        return pizza;
    }
}

// 客户端调用
Pizza pizza = new PizzaBuilder()
    .addCheese()
    .addPepperoni()
    .build();