【设计模式】UML类图与工厂模式

UML图

  类封装了数据和行为，是面向对象的重要组成部分，它是具有相同属性、操作、关系的对象集合的总称

有以下UML图，分析如下：

• 可见性： + 表示public、# 表示protected、- 表示private、__(下划线)表示static
• 属性的表示方式：【可见性】【属性名称】:【类型】= { 缺省值，可选 }
• 方法的表示方式：【可见性】【方法名称】(【参数名 : 参数类型，……】）:【返回值类型】

定义的类是一个抽象类（类中有纯虚函数），在画UML类图的时候，类名需要使用斜体显示，并在最后给函数指定=0。

设计模式三原则

单一职责原则

• 核心思想： ​​一个类应该只有一个引起它变化的原因​​（即一个类只负责一项职责）
• 通俗理解： 即一个类只负责一项职责，一个类不要 “身兼数职”
• 关键点： 将不同职责分离到不同的类中，职责分离

开闭原则

• 核心思想： 软件实体（类、模块、函数）应对扩展开放，对修改关闭​​
• 通俗理解​​： 新增功能时尽量通过扩展（如继承、组合）实现，而非修改已有代码

里氏替换原则

• 核心思想： 子类必须能够替换父类且不影响程序的正确性​​
• ​​通俗理解​​： 子类要能包含父类的所有属性和方法

三者关系与总结​​

简单工厂模式

提供一个静态方法或普通方法，根据输入参数（如类型标识）决定创建并返回哪种具体类的实例。

• 工厂类（SimpleFactory）​​：负责创建具体产品，包含判断逻辑。
• ​​抽象产品（Product）​​：定义产品的公共接口（通常是抽象类或接口）
• 具体产品（ConcreteProduct）​​：实现抽象产品的具体类。

简单工厂模式相关类的创建和使用步骤如下：

1. 定义一个抽象产品基类Product，作为各个对象的基类，
2. 创建一个工厂类，并且为工厂类添加公共成员函数，通过这个函数来创建我们需要的对象，这个函数称为工厂函数。简单工厂需要的工厂类只只有一个。
3. 关于工厂函数，返回的是基类指针，以此实现多态，函数体则根据不同的枚举类型创建不同的对象实例
4. 关于使用，首先创建一个工厂类对象，然后通过这个对象调用工厂函数，这样就可以生产出一个指定类型的实例对象了。

相关UML类图与实例代码如下：

#include <bits/stdc++.h>

using namespace std;

// 从而实现对象的解耦合, 同时增强了程序的扩展性
// 抽象产品接口
class Product {
public:
    virtual ~Product() = default;
    virtual void operation() const = 0;
};

// 具体产品类A
class ConcreteProductA : public Product {
public:
    void operation() const override {
        cout << "ConcreteProductA operation" << endl;
    }
};

// 具体产品类B
class ConcreteProductB : public Product {
public:
    void operation() const override {
        cout << "ConcreteProductB operation" << endl;
    }
};

// 工厂类
class SimpleFactory {
public:
    static Product* createProduct(char type) {
    	switch(type)
    	{
    		case 'A':	 return new ConcreteProductA();	break;
    		case 'B':	 return new ConcreteProductB();	break;
    		default:	break;
    	}
    }
};

// 客户端代码
int main() {
    char type;
    cout << "Enter product type (A or B): ";
    cin >> type;

    Product* product = SimpleFactory::createProduct(type);
    product->operation();
    delete product;  // 手动释放内存
 
    return 0;
}

说明：

• 基类的析构函数应该是虚函数，这样才能够通过父类指针或引用析构子类的对象。
• 工厂函数返回值为基类指针，指向子类对象的地址，实现多态
• 简单工厂模式的工厂函数是违背了开闭原则的

工厂模式

  在上面的简单工厂模式的工厂函数中需要创建不同的实例对象，现在如果想要生成更多实例对象，那么就需要在工厂函数的switch语句中添加更多的case，很明显这违背了封闭原则，也就意味着需要基于开放原则来解决这个问题。

简单工厂模式是只有一个工厂类，而工厂模式是有很多的工厂类：

• 一个基类，包含一个虚工厂函数，用于实现多态。
• 多个子类，重写父类的工厂函数。每个子工厂类负责生产一种产品的实例对象，这相当于再次解耦，将工厂类的职责再次拆分、细化，如果要生产新品种的恶魔果实，那么只需要添加对应的工厂类，无需修改原有的代码。

相关UML类图与实例代码如下：

#include <iostream>
using namespace std;

// 抽象产品接口
class Product {
public:
    virtual ~Product() = default;
    virtual void operation() const = 0;
};

// 具体产品类A
class ConcreteProductA : public Product {
public:
    void operation() const override {
        cout << "ConcreteProductA operation" << endl;
    }
};

// 具体产品类B
class ConcreteProductB : public Product {
public:
    void operation() const override {
        cout << "ConcreteProductB operation" << endl;
    }
};

// 工厂接口
class Factory {
public:
    virtual ~Factory() = default;
    virtual Product* createProduct() const = 0;
};

// 具体工厂类A
class ConcreteFactoryA : public Factory {
public:
    Product* createProduct() const override {
        return new ConcreteProductA();
    }
};

// 具体工厂类B
class ConcreteFactoryB : public Factory {
public:
    Product* createProduct() const override {
        return new ConcreteProductB();
    }
};

// 客户端代码
int main() {
    char type;
    cout << "Enter product type (A or B): ";
    cin >> type;

    Factory* factory = nullptr;
    if (type == 'A') {
        factory = new ConcreteFactoryA();
    } else if (type == 'B') {
        factory = new ConcreteFactoryB();
    } else {
        cerr << "Unknown product type" << endl;
        return 1;
    }

    Product* product = factory->createProduct();
    product->operation();
    
    delete product;  // 手动释放产品对象
    delete factory;  // 手动释放工厂对象

    return 0;
}

  在真实的项目场景中，要生成什么类型的具体产品（ConcreteProductA/B）其实是通过客户端的操作界面控制的，它对应的可能是一个按钮或者是一个选择列表，用户做出了选择，程序就可以根据该需求去创建对应的工厂对象，最终将选择的具体产品生产出来。