基于类的四种设计模式

最新推荐文章于 2025-10-07 10:15:42 发布
原创 最新推荐文章于 2025-10-07 10:15:42 发布 · 888 阅读 · 26 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#设计模式

1. 工厂方法模式 (Factory Method)

问题

当系统需要创建对象，但具体类型在编译时无法确定，或者创建逻辑复杂需要封装时，直接使用new关键字会导致代码耦合度高、难以扩展。

解决方案

定义一个创建对象的接口，但让子类决定实例化哪个类。工厂方法让类的实例化推迟到子类。

组件框图

┌─────────────────┐         ┌──────────────────┐
│    Creator      │         │    Product       │
├─────────────────┤         ├──────────────────┤
│+factoryMethod() │───────>│                  │
└─────────────────┘         └──────────────────┘
         ▲                            ▲
         │                            │
┌─────────────────┐         ┌──────────────────┐
│ ConcreteCreator │         │ ConcreteProduct  │
├─────────────────┤         ├──────────────────┤
│+factoryMethod() │         │                  │
└─────────────────┘         └──────────────────┘

效果

优点：

  • 符合开闭原则，易于扩展新产品

  • 客户端与具体产品类解耦

  • 将创建逻辑集中管理

缺点：

  • 每增加一个产品就需要增加一个具体工厂类

  • 增加了系统的复杂度

代码示例（Python重点展示）

from abc import ABC, abstractmethod

class Document(ABC):
    @abstractmethod
    def open(self):
        pass
    
    @abstractmethod
    def save(self):
        pass

class WordDocument(Document):
    def open(self):
        print("打开Word文档")
    
    def save(self):
        print("保存Word文档")

class PDFDocument(Document):
    def open(self):
        print("打开PDF文档")
    
    def save(self):
        print("保存PDF文档")

class Application(ABC):
    def __init__(self):
        self.documents = []
    
    @abstractmethod
    def create_document(self) -> Document:
        pass
    
    def new_document(self):
        doc = self.create_document()
        self.documents.append(doc)
        doc.open()
        return doc

class WordApplication(Application):
    def create_document(self) -> Document:
        return WordDocument()

class PDFApplication(Application):
    def create_document(self) -> Document:
        return PDFDocument()

# 使用
app = WordApplication()
doc = app.new_document()  # 输出: 打开Word文档

2. 基于类的适配器模式 (Class Adapter)

问题

现有类的接口与客户端期望的接口不兼容，但需要让它们能够协同工作，且不希望修改现有代码。

解决方案

通过多重继承（或实现接口+继承）创建一个适配器类，它同时继承目标接口和被适配者，在适配器类中实现接口转换。

组件框图

┌─────────────────┐         ┌──────────────────┐
│    Client       │         │    Target        │
├─────────────────┤         ├──────────────────┤
│                 │───────>│+request()        │
└─────────────────┘         └──────────────────┘
                                    ▲
                                    │
                           ┌──────────────────┐
                           │    Adapter       │
                           ├──────────────────┤
                           │+request()        │
                           └──────────────────┘
                                    ▲
                                    │
                           ┌──────────────────┐
                           │   Adaptee        │
                           ├──────────────────┤
                           │+specificRequest()│
                           └──────────────────┘

效果

优点：

  • 可以让任何两个没有关联的类一起运行

  • 提高了类的复用性

  • 符合开闭原则

缺点：

  • 过多使用适配器会让系统变得混乱

  • 由于使用继承，限制了适配器的灵活性

代码示例（C++重点展示）

#include <iostream>
#include <string>

// 目标接口 - 欧洲插座
class EuropeanSocket {
public:
    virtual ~EuropeanSocket() = default;
    virtual void plugIn() = 0;
    virtual int getVoltage() = 0;
};

// 被适配者 - 美国插座
class AmericanSocket {
public:
    void connect() {
        std::cout << "美国插座连接" << std::endl;
    }
    
    int getUSVoltage() {
        return 110;  // 110V
    }
};

// 适配器 - 旅行转换器
class SocketAdapter : public EuropeanSocket, private AmericanSocket {
public:
    void plugIn() override {
        std::cout << "使用适配器连接: ";
        connect();  // 调用被适配者的方法
        std::cout << "将电压从" << getUSVoltage() << "V转换到" << getVoltage() << "V" << std::endl;
    }
    
    int getVoltage() override {
        return 220;  // 转换为欧洲电压
    }
};

// 欧洲电器
class EuropeanDevice {
public:
    void use(EuropeanSocket* socket) {
        socket->plugIn();
        std::cout << "设备在 " << socket->getVoltage() << "V 电压下工作" << std::endl;
    }
};

// 使用
int main() {
    EuropeanDevice device;
    SocketAdapter adapter;
    
    device.use(&adapter);
    return 0;
}

3. 解释器模式 (Interpreter)

问题

需要解释执行特定语言或文法规则，且文法规则可以表示为层次结构。例如：正则表达式、数学表达式、SQL查询等。

解决方案

定义文法的类层次结构，每个规则对应一个类，通过组合模式构建抽象语法树，实现解释操作。

组件框图

┌─────────────────┐         ┌──────────────────┐
│   Client        │         │  AbstractExpression
├─────────────────┤         ├──────────────────┤
│                 │───────>│+interpret(Context)│
└─────────────────┘         └──────────────────┘
                                          △
                         ┌────────────────┼────────────────┐
             ┌────────────┴────────────┐    ┌──────────────┴────────────┐
             │     TerminalExpression  │    │  NonterminalExpression    │
             ├─────────────────────────┤    ├───────────────────────────┤
             │+interpret(Context)      │    │+interpret(Context)        │
             └─────────────────────────┘    │-expression                │
                                            └───────────────────────────┘

效果

优点：

  • 易于改变和扩展文法

  • 实现文法很容易，类层次结构清晰

  • 易于实现简单文法

缺点：

  • 复杂的文法难以维护

  • 执行效率较低

  • 类数量会随着规则增加而增加

代码示例（C#重点展示）

using System;
using System.Collections.Generic;

// 上下文 - 存储变量值
public class Context
{
    private Dictionary<string, bool> variables = new Dictionary<string, bool>();
    
    public void SetVariable(string name, bool value)
    {
        variables[name] = value;
    }
    
    public bool GetVariable(string name)
    {
        return variables.ContainsKey(name) ? variables[name] : false;
    }
}

// 抽象表达式
public interface IExpression
{
    bool Interpret(Context context);
}

// 终结符表达式 - 变量
public class VariableExpression : IExpression
{
    private string name;
    
    public VariableExpression(string name)
    {
        this.name = name;
    }
    
    public bool Interpret(Context context)
    {
        return context.GetVariable(name);
    }
}

// 终结符表达式 - 常量
public class ConstantExpression : IExpression
{
    private bool value;
    
    public ConstantExpression(bool value)
    {
        this.value = value;
    }
    
    public bool Interpret(Context context)
    {
        return value;
    }
}

// 非终结符表达式 - 与操作
public class AndExpression : IExpression
{
    private IExpression left;
    private IExpression right;
    
    public AndExpression(IExpression left, IExpression right)
    {
        this.left = left;
        this.right = right;
    }
    
    public bool Interpret(Context context)
    {
        return left.Interpret(context) && right.Interpret(context);
    }
}

// 非终结符表达式 - 或操作
public class OrExpression : IExpression
{
    private IExpression left;
    private IExpression right;
    
    public OrExpression(IExpression left, IExpression right)
    {
        this.left = left;
        this.right = right;
    }
    
    public bool Interpret(Context context)
    {
        return left.Interpret(context) || right.Interpret(context);
    }
}

// 非终结符表达式 - 非操作
public class NotExpression : IExpression
{
    private IExpression expression;
    
    public NotExpression(IExpression expression)
    {
        this.expression = expression;
    }
    
    public bool Interpret(Context context)
    {
        return !expression.Interpret(context);
    }
}

// 使用
class Program
{
    static void Main()
    {
        // 构建上下文：A=true, B=false, C=true
        Context context = new Context();
        context.SetVariable("A", true);
        context.SetVariable("B", false);
        context.SetVariable("C", true);
        
        // 构建表达式: (A AND B) OR (NOT C)
        IExpression expression = new OrExpression(
            new AndExpression(
                new VariableExpression("A"),
                new VariableExpression("B")
            ),
            new NotExpression(
                new VariableExpression("C")
            )
        );
        
        bool result = expression.Interpret(context);
        Console.WriteLine($"表达式 (A AND B) OR (NOT C) 的结果: {result}");
        // 计算: (true AND false) OR (NOT true) = false OR false = false
        
        // 另一个表达式: A OR (B AND C)
        IExpression expression2 = new OrExpression(
            new VariableExpression("A"),
            new AndExpression(
                new VariableExpression("B"),
                new VariableExpression("C")
            )
        );
        
        bool result2 = expression2.Interpret(context);
        Console.WriteLine($"表达式 A OR (B AND C) 的结果: {result2}");
        // 计算: true OR (false AND true) = true OR false = true
    }
}

4. 模板方法模式 (Template Method)

问题

多个类有相同的工作步骤，但某些步骤的具体实现不同。需要在保持算法结构不变的前提下，允许子类重新定义某些步骤。

解决方案

在抽象类中定义算法的骨架，将一些步骤的实现推迟到子类中。模板方法使得子类可以不改变算法结构的情况下重新定义算法的某些步骤。

组件框图

┌─────────────────┐
│ AbstractClass   │
├─────────────────┤
│+templateMethod()│
│+step1()         │
│+step2()         │
│#primitiveOp1()  │
│#primitiveOp2()  │
│#hook()          │
└─────────────────┘
         △
         │
┌─────────────────┐
│ ConcreteClass   │
├─────────────────┤
│#primitiveOp1()  │
│#primitiveOp2()  │
│#hook()          │
└─────────────────┘

效果

优点：

  • 代码复用，将不变行为移到超类

  • 符合开闭原则，易于扩展

  • 便于维护，算法结构集中管理

缺点：

  • 每个不同的实现都需要一个子类

  • 超类中的抽象方法必须由子类实现

  • 可能违反里氏替换原则

详细代码示例（Python）

from abc import ABC, abstractmethod
from datetime import datetime

class ReportGenerator(ABC):
    """报表生成器模板类"""
    
    def generate_report(self):
        """模板方法 - 定义报表生成流程"""
        self.collect_data()
        self.process_data()
        self.format_report()
        if self.needs_export():
            self.export_report()
        self.cleanup()
    
    def collect_data(self):
        """具体方法 - 收集数据（所有报表通用）"""
        print(f"[{datetime.now()}] 开始收集数据...")
        # 模拟数据收集
        self.data = ["数据1", "数据2", "数据3"]
        print("数据收集完成")
    
    @abstractmethod
    def process_data(self):
        """抽象方法 - 处理数据（子类必须实现）"""
        pass
    
    @abstractmethod
    def format_report(self):
        """抽象方法 - 格式化报表（子类必须实现）"""
        pass
    
    def export_report(self):
        """钩子方法 - 导出报表（子类可选重写）"""
        print("默认导出为PDF格式")
    
    def needs_export(self):
        """钩子方法 - 是否需要导出（子类可选重写）"""
        return True
    
    def cleanup(self):
        """具体方法 - 清理资源（所有报表通用）"""
        print("清理临时数据和资源...")

class SalesReportGenerator(ReportGenerator):
    """销售报表生成器"""
    
    def process_data(self):
        """实现销售数据处理的特定逻辑"""
        print("处理销售数据: 计算销售额、增长率等指标")
        self.processed_data = [f"销售指标: {item}" for item in self.data]
    
    def format_report(self):
        """实现销售报表的特定格式"""
        print("格式化销售报表: 使用图表展示销售趋势")
        print("生成的报表内容:", self.processed_data)
    
    def export_report(self):
        """重写导出方法 - 销售报表需要多种格式"""
        print("导出销售报表: PDF, Excel, 和HTML格式")

class FinancialReportGenerator(ReportGenerator):
    """财务报表生成器"""
    
    def process_data(self):
        """实现财务数据处理的特定逻辑"""
        print("处理财务数据: 计算利润、资产负债表等项目")
        self.processed_data = [f"财务项目: {item}" for item in self.data]
    
    def format_report(self):
        """实现财务报表的特定格式"""
        print("格式化财务报表: 使用表格展示财务数据")
        print("生成的报表内容:", self.processed_data)
    
    def needs_export(self):
        """重写钩子方法 - 财务报表不需要自动导出"""
        return False
    
    def audit_trail(self):
        """财务报表特有的审计追踪方法"""
        print("生成审计追踪记录")

class InventoryReportGenerator(ReportGenerator):
    """库存报表生成器"""
    
    def process_data(self):
        """实现库存数据处理的特定逻辑"""
        print("处理库存数据: 计算库存周转率、安全库存等")
        self.processed_data = [f"库存指标: {item}" for item in self.data]
    
    def format_report(self):
        """实现库存报表的特定格式"""
        print("格式化库存报表: 使用条形图展示库存水平")
        print("生成的报表内容:", self.processed_data)
    
    def export_report(self):
        """重写导出方法 - 库存报表需要实时同步"""
        print("导出库存报表并同步到ERP系统")

# 客户端代码
def main():
    print("=== 销售报表生成 ===")
    sales_report = SalesReportGenerator()
    sales_report.generate_report()
    
    print("\n=== 财务报表生成 ===")
    financial_report = FinancialReportGenerator()
    financial_report.generate_report()
    
    print("\n=== 库存报表生成 ===")
    inventory_report = InventoryReportGenerator()
    inventory_report.generate_report()

if __name__ == "__main__":
    main()

模式对比总结

模式主要目的适用场景关键特性
工厂方法对象创建解耦创建逻辑复杂或运行时确定类型子类决定创建对象
适配器模式接口转换集成不兼容的接口继承+接口实现
解释器模式语言解释特定领域语言处理文法类层次结构
模板方法算法骨架固定多个类有相同流程但不同实现抽象类定义模板

这些模式都体现了面向对象设计的重要原则：开闭原则、依赖倒置原则和里氏替换原则，在实际开发中可以根据具体需求灵活选用。

如何正规的、大气的设计一个类？
「小白学移动机器人」一个专注分享移动机器人相关知识的公众号！
12-17 1184
如何正规的、大气的设计一个类？ 1、前言 本篇文章主要是培养正规的、大气的编程习惯，文章的构思来源来自中国台湾著名专家侯捷 – c++面向对象程序设计课程。 每个人的编程水平都不一样，所以本篇文章对于一部分人来说，可能并没有什么用；文章主要想给大家传达一种设计习惯。 2、类（class）设计的分类 这里明确将类的设计分成基于对象和面向对象两种，逐步深入。 基于对象设计的类：也即是简单的类，没有类间关系的类，这里又被分为，不含指针成员的类和含指针成员的类。 面向对象设计的类：也即是复杂的类，含有类间关系的类，
C++设计模式--基于Qt4开源跨平台开发框架
01-06
《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式，并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念，它们是经过时间和实践验证的解决特定问题的模板...
第五章 - 类的分析与设计
qq_42739587的博客
03-10 7608
定义 对未来系统的功能进行总体上的概括并使用UML的类图进行表达。 在开始阶段粗略的对模型进行构建，后续再通过迭代逐级具体化，是一个逐步求精的设计过程。 初始类图要覆盖所有需求的功能，并通过优化尽量保持业务结构的稳定，然后通过修订和丰富细节逐渐过渡到详细设计，并最终转化为成功的物理实现。 基本类的确定 设计阶段的主要任务是从需求分析阶段的规格说明出发，对系统进行模型表示并优化。 面向对象的概要设计首先寻找系统中参与业务处理的对象和类。 然后使用类图（Class Diagram）将系统中不同的类抽象出来
类的设计和实现
y2940681148的博客
10-23 962
(1)有无返回值和有无形式参数划分为四种：1无参无返回（void） 2无参有明确返回值 3带参无返回值（void） 4带参有明确返回值。(2)子类继承父类后默认继承父类的构造方法，即字类存在隐含方法super()，如果子类重写构造则字类也隐含调用super()。2：成员方法：描述对象所具有的功能或行为，是具有某种相对独立功能的程序模块，作用主要是操作类自身属性。(1)例如 Person p=new Person(“a”) a为构造的实际参数。(1)成员变量：存在堆内存和类一起定义。
23种设计模式
最新发布
Made In SQL
10-07 912
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。特点产品族概念：一组具有相同主题的产品更换产品族只需更换具体工厂增加新产品需要修改所有工厂类。
类的设计方法
键者天行
07-13 7041
1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。例如： ThisIsAClassName thisIsMethodOrFieldName 若在定义中出现了常数初始化字符，则大写static final基本类型标识符中的所有字母。这样便可标志出它们属于编译期的常数。 Java包（Package）属于一种特
类设计
weixin_30602505的博客
08-16 412
类设计 类的设计方法　[转] from:http://www.cnblogs.com/seandotnet/archive/2006/12/25/603114.html 1) 类名首字母应该大写。字段、方法以及对象（句柄）的首字母应小写。对于所有标识符，其中包含的所有单词都应紧靠在一起，而且大写中间单词的首字母。例如： ThisIsAClassName thisIsMethodOrFie...
精选资源
基于Java采用5种设计模式开发的(GUI)五子棋【100012593】
06-05
本项目一共使用了5种设计模式，分别是工厂方法模式、享元模式、备忘录模式、观察者模式、策略模式。其中工厂方法模式给用户选择背景音乐、享元模式用于设计五子棋的棋子类、备忘录模式来实现悔棋功能，观察者模式来...
基于Android的设计模式示例.zip
09-06
基于Android的设计模式示例 项目简介 本项目是一个基于Android平台的设计模式示例集合，旨在通过实际代码展示常见设计模式的应用。项目涵盖了多种设计模式，包括但不限于适配器模式、命令模式、装饰器模式、工厂...
RSA介绍：了解基于设计模式的开发
03-04
本文向您介绍设计模式的基础，并解释了IBMRationalSoftwareArchitect如何促进基于设计模式的开发。文中还介绍了一些关于设计模式的实例，并告诉您如何快速地建立类图及生成基于这些模式的代码。后继的文章将更详细地...
基于Java的设计模式示例集.zip
09-08
本项目是一个基于Java语言实现的设计模式示例集，涵盖了23种经典的设计模式。每个设计模式都有详细的代码示例和解释，帮助开发者理解和应用这些设计模式。项目旨在通过实际代码演示，帮助开发者掌握设计模式的核心...
类的设计
我喜欢雨天的清新的博客
12-18 382
成员变量在c++中在同一访问限定符下的成员变量的声明顺序与初始化顺序一致，所以设计的时候尽量把成员变量都放到同一个限定符下。成员函数成员函数的限定符可以自定义，最好不同模块不同的限定符修饰，不要全放在同一个限定符下，这样方便维护。eg: class eg { public : /*模块A的函数*/ ... public: /*模块B的函数*/ ..
类别的设计
像风走过八千里
03-03 424
介面1、依据协定设计类别（1） 先制定协定，再实作 （2） 优点 事前的规则使类别更完善 较佳的类别版本控制取向 使用起来较有弹性（3） 使用介面制定协定2、介面代表用户端与伺服端之间的协定，不包含资料及任何实作的程式码 程式码易动时，使用介面，不需要改程式码3、多型不同的类别均支援相同的操作 使用介面轻易就可实作多型4、泛用型资料层使用ADO.NET的介面来开发泛用型的资料元件
类的设计（1）
m0_51972034的博客
08-23 486
侯捷c++高级编程学习
类的设计概述
CherryPeng的专栏
04-09 1217
类的设计概述 编写程序前的设计与思考1.分析业务,从业务流和业务规则中归纳出领域对象.这些对象一般放在src/com/yourname/domain下.2.根据业务,考虑为领域对象提供完整的服务需要那些服务类.这些对象一般放在src/com/yourname/service下.3.思考从输入开始,到输出结束,程序要运行正常,服务类需要那些属性和方法,这些成员代表什么意义具有什么价值,方法的
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值