【重走编程路】设计模式概述（七） -- 外观模式、组合模式、享元模式

news/2024/8/22 18:33:34 标签: 设计模式, 外观模式, 组合模式, 享元模式

文章目录

  • 前言
  • 10. 外观模式（Facade）
    • 定义
    • 解决方案
    • 为什么使用外观模式
    • 应用场景
    • 优缺点
  • 11. 组合模式（Composite）
    • 定义
    • 解决方案
    • 应用场景
    • 优缺点
  • 12. 享元模式（Flyweight）
    • 定义
    • 解决方案
    • 应用场景
    • 优缺点

前言

结构型模式关注如何组合对象以形成更大的结构，提供了一种将对象组合成具有特定行为的结构的最佳方式。本章介绍结构型模式中的外观模式、组合模式和享元模式。

10. 外观模式（Facade）

定义

外观模式，又称门面模式，是一种结构型设计模式。它为子系统中的一组接口提供一个统一的接口，从而简化子系统的复杂性，使得外部系统只需与这个统一接口交互，而无需关心子系统内部的复杂细节。外观模式通过定义一个高层次的接口，将客户端与子系统的内部复杂性隔离开来，提高了系统的可维护性和易用性。

解决方案

外观模式通过引入一个外观类（Facade），将复杂的子系统接口进行封装，为客户端提供一个简单的高层接口。外观类充当了客户端与子系统之间的中间人，处理客户端的请求并将其转发给适当的子系统。外观模式并不在系统中添加新功能，它只是提供了一个更简洁的接口，以简化客户端的操作。

为什么使用外观模式

1. 简化接口： 通过为复杂的子系统提供一个简单的接口，降低了客户端的复杂度。
2. 减少系统间的依赖： 客户端只需与外观类交互，而无需直接依赖于子系统的多个类，从而减少了系统间的耦合。
3. 提高灵活性： 在不改变客户端代码的情况下，可以轻松地更改或扩展子系统的内部结构。

假设我们有一个复杂的图形编辑软件，它包含了多个子系统，如绘图子系统、颜色管理子系统和字体管理子系统。我们可以使用一个外观类来封装这些子系统的功能，并提供一个简单的接口给用户使用。

#include <iostream>  
// 绘图子系统  
class DrawingSystem {
public:
    void drawCircle() {
        std::cout << "Drawing a circle\n";
    }
    void drawRectangle() {
        std::cout << "Drawing a rectangle\n";
    }
};

// 颜色管理子系统  
class ColorSystem {
public:
    void setForegroundColor(const std::string& color) {
        std::cout << "Setting foreground color to " << color << "\n";
    }
};

// 字体管理子系统  
class FontSystem {
public:
    void setFont(const std::string& font) {
        std::cout << "Setting font to " << font << "\n";
    }
};

// 外观类  
class GraphicsFacade {
private:
    DrawingSystem* drawingSystem;
    ColorSystem* colorSystem;
    FontSystem* fontSystem;

public:
    GraphicsFacade() : drawingSystem(new DrawingSystem()), colorSystem(new ColorSystem()), fontSystem(new FontSystem()) {}
    ~GraphicsFacade() {
        delete drawingSystem;
        delete colorSystem;
        delete fontSystem;
    }
    void drawShapedText(const std::string& shape, const std::string& text, const std::string& color, const std::string& font) {
        colorSystem->setForegroundColor(color);
        fontSystem->setFont(font);
        if (shape == "circle") {
            drawingSystem->drawCircle();
        }
        else if (shape == "rectangle") {
            drawingSystem->drawRectangle();
        }
        // 假设这里还有绘制文本的代码  
        std::cout << "Drawing text: " << text << "\n";
    }
};

int main() {
    GraphicsFacade facade;
    facade.drawShapedText("circle", "Hello, World!", "blue", "Arial");
    return 0;
}

应用场景

  1. 当一个系统非常复杂，客户端与多个子系统交互时，可以使用外观模式来简化交互。
  2. 当需要为复杂的子系统提供一个简单的接口时。
  3. 当客户端和子系统之间存在大量的依赖关系，需要降低它们之间的耦合度时。

优缺点

优点：

  • 降低了客户端与子系统的耦合度。
  • 简化了客户端代码，提高了系统的易用性。
  • 提高了系统的灵活性和可扩展性，可以在不修改客户端代码的情况下更改子系统的实现。

缺点：

  • 如果设计不当，可能会隐藏子系统的某些功能，导致客户端无法直接访问。
  • 外观类可能会变得过于庞大，增加系统的复杂性。
  • 过度使用外观模式可能会导致系统内部层次结构不清晰，增加理解和维护的难度。

11. 组合模式（Composite）

定义

组合模式是一种结构型设计模式，它将对象组合成树形结构以表示 “部分-整体” 的层次结构。在这种模式中，客户端代码可以一致地处理单个对象和组合对象，无需区分它们之间的差别。组合模式也被称为“整体-部分”模式。

解决方案

组合模式主要解决在对象组合中表示整体和部分关系的问题，提供了一种方式来创建对象的层次结构，其中部分可以像整体一样被处理。通过定义共同的接口或基类（Component），并在其中声明管理子对象的方法（如添加、删除、获取子对象等），无论是叶子节点（Leaf）还是容器节点（Composite）都实现了这个接口或继承了这个基类。容器节点可以包含其他容器节点或叶子节点，从而形成一个树形结构。

// 文件系统
#include <iostream>  
#include <vector>  
#include <memory>  
  
class FileSystemComponent {  
public:  
    virtual ~FileSystemComponent() {}  
    virtual void display(int level = 0) const = 0;  
  
protected:  
    std::string name;  
    // 文件基类，不允许外部创建
    FileSystemComponent(const std::string& name) : name(name) {}  
};  
  
class File : public FileSystemComponent {  
public:  
    File(const std::string& name) : FileSystemComponent(name) {}  
    void display(int level = 0) const override {  
        for (int i = 0; i < level; ++i) {  
            std::cout << "  ";  
        }  
        std::cout << "File: " << name << std::endl;  
    }  
};  
  
class Folder : public FileSystemComponent {  
public:  
    Folder(const std::string& name) : FileSystemComponent(name) {}  
    
    void add(std::shared_ptr<FileSystemComponent> component) {  
        components.push_back(component);  
    }  
    
    void display(int level = 0) const override {  
        for (int i = 0; i < level; ++i) {  
            std::cout << "  ";  
        }  
        std::cout << "Folder: [" << name << "]" << std::endl;  
        for (const auto& comp : components) {  
            comp->display(level + 1);  
        }  
    }  
  
private:  
    std::vector<std::shared_ptr<FileSystemComponent>> components;  
};  
  
int main() {  
    // 创建文件和文件夹  
    std::shared_ptr<File> file1 = std::make_shared<File>("File1.txt");  
    std::shared_ptr<File> file2 = std::make_shared<File>("File2.txt");  
    std::shared_ptr<Folder> folder1 = std::make_shared<Folder>("Folder1");  
  
    // 将文件添加到文件夹  
    folder1->add(file1);  
    folder1->add(file2);  
  
    // 创建另一个文件夹并添加文件和子文件夹  
    std::shared_ptr<Folder> folder2 = std::make_shared<Folder>("Folder2");  
    folder2->add(file1);  
    folder2->add(folder1);  
  
    // 显示整个文件系统结构  
    folder2->display();  
  
    return 0;  
}

应用场景

  1. 表示对象的部分-整体层次结构： 如文件和文件夹系统、公司的组织结构等。
  2. 菜单系统： 菜单项可以包含子菜单项，形成层次结构。
  3. 图形界面（GUI）： 表示窗口、按钮和菜单项等控件的树形结构。
  4. XML文档解析： XML文档中的元素可以包含子元素和文本内容，形成嵌套结构。

优缺点

优点：

  • 简化客户端代码： 客户端可以使用相同的代码处理单个对象和组合对象。
  • 较高的可扩展性： 容易在组合体内增加新的对象，客户端代码不需要修改。
  • 容易创建复杂的层次结构： 客户端无需知道组合的内部结构，就可以轻松构建复杂的树形结构。

缺点：

  • 设计复杂： 类层次结构可能变得复杂，增加了理解和维护的难度。
  • 性能问题： 在处理大型树形结构时，递归操作可能导致性能问题。
  • 接口限制： 要求所有组件都实现相同的接口，限制了组件的特异性。如果某些组件需要特殊的操作或属性，而这些操作或属性不适用于其他组件，那么将它们强制实现相同的接口可能会导致设计上的不合理或冗余。

12. 享元模式（Flyweight）

定义

享元模式旨在通过共享尽可能多的相似对象来减少内存中的对象数量，从而提高程序的效率和性能。在享元模式中，会区分出内部状态（不随环境改变而改变）和外部状态（随环境改变而改变），并通过共享内部状态来减少对象的数量。享元对象自身通常很小且不可变，以支持高效的共享。

解决方案

享元模式的解决方案通常包含以下几个关键部分：

  1. 享元接口（Flyweight）： 定义一个接口，通过这个接口可以访问享元对象的内部状态，并可能允许设置外部状态。
  2. 具体享元类（Concrete Flyweight）： 实现享元接口，为内部状态提供存储空间。如果享元类需要外部状态，则必须通过构造函数或特定方法将其传入。
  3. 享元工厂类（Flyweight Factory）： 负责创建和管理享元对象。为了确保享元对象的唯一性，享元工厂类通常会使用一个存储结构（如哈希表）来存储已经创建的享元对象。
  4. 客户端（Client）： 在需要使用享元对象时，通过享元工厂获取它们，并设置外部状态（如果需要的话）。

假设我们有一个文本编辑器，需要频繁地显示和编辑不同字体和大小的文本。我们可以使用享元模式来共享具有相同字体和大小的文本对象，而仅将文本内容作为外部状态传递。

#include <iostream>  
#include <unordered_map>  
#include <string>  
  
// 享元接口  
class Flyweight {  
public:  
    virtual ~Flyweight() {}  
    virtual void operation(std::string extrinsicState) = 0;  
};  
  
// 具体享元类，代表具有特定字体和大小的文本  
class ConcreteFlyweight : public Flyweight {  
private:  
    std::string intrinsicState; // 内部状态，如字体和大小  
  
public:  
    ConcreteFlyweight(const std::string& state) : intrinsicState(state) {}  
  
    void operation(std::string extrinsicState) override {  
        std::cout << "Intrinsic: " << intrinsicState << ", Extrinsic: " << extrinsicState << std::endl;  
    }  
};  
  
// 享元工厂类  
class FlyweightFactory {  
private:  
    std::unordered_map<std::string, Flyweight*> flyweights;  
  
public:  
    Flyweight* getFlyweight(const std::string& key) {  
        if (flyweights.find(key) == flyweights.end()) {  
            flyweights[key] = new ConcreteFlyweight(key);  
        }  
        return flyweights[key];  
    }  
};  
  
// 客户端  
int main() {  
    FlyweightFactory factory;  
  
    // 获取具有相同内部状态的享元对象  
    Flyweight* f1 = factory.getFlyweight("Arial-12");  
    Flyweight* f2 = factory.getFlyweight("Arial-12");  
  
    // 设置外部状态并执行操作  
    f1->operation("Hello, World!");  
    f2->operation("Another text.");  
  
    // 验证f1和f2是否指向同一对象  
    std::cout << "f1 and f2 are the same object: " << (f1 == f2) << std::endl; // 应输出 1 (true)  
  
    return 0;  
}

应用场景

享元模式适用于以下场景：

  1. 当一个应用程序使用了大量的对象，而这些对象的大量数据可以外部化时。
  2. 当对象的多数状态可以外部化，并且这些对象可以被多个客户端共享时。
  3. 当存储大量细粒度对象的开销过高，需要节省内存时。

优缺点

优点：

  • 减少了对象的数量，降低了内存占用。
  • 提高了效率，因为减少了创建和销毁对象的开销。
  • 外部状态使得对象可以在不同上下文中重用。

缺点：

  • 增加了程序的复杂度，因为需要区分内部状态和外部状态。
  • 如果不恰当地使用外部状态，可能会导致程序错误。
  • 如果享元对象过多，享元工厂的管理可能会变得复杂。

…

To be continued.


http://www.niftyadmin.cn/n/5556543.html

相关文章

智慧园区软件平台设计方案Word（1129页）

智慧园区软件平台设计方案Word（1129页）

1. 智慧园区大数据平台的建设目的是通过智慧化手段提升园区吸引力、促进园区可持续发展、助力园区发展战略性新兴产业&#xff0c;并顺应信息技术创新与应用趋势。平台的基础设施建设包括管委会大楼智能化、园区主干网敷设、应急指挥中心等&#xff0c;以实现对园区各项活动的智…
阅读更多...
Android系统上常见的性能优化工具

Android系统上常见的性能优化工具

Android系统上常见的性能优化工具 在Android系统开发中&#xff0c;性能优化是一个重要的任务&#xff0c;有许多工具可以帮助你进行各种方面的性能分析和优化。以下是一些常见的Android性能优化工具及其用途和使用方法&#xff1a; 1. Android Studio Profiler 功能: 提供CP…
阅读更多...
小程序-模板与配置

小程序-模板与配置

一、WXML模板语法 1.数据绑定 2.事件绑定 什么是事件 小程序中常用的事件 事件对象的属性列表 target和currentTarget的区别 bindtap的语法格式 在事件处理函数中为data中的数据赋值 事件传参 &#xff08;以下为错误示例&#xff09; 3.事件传参与数据同步 4.条件渲染 …
阅读更多...
C++ 类和对象(A)

C++ 类和对象(A)

一、类与对象的初步认识 1.类是对象的抽象&#xff0c;而对象是类的具体实例。 类是抽象的&#xff0c;不占用内存&#xff1b;而对象是具体的&#xff0c;占用存储空间。 2.面向过程与面向对象 C语言是面向过程的&#xff0c;关注的是过程中的数据与方法。 C是面向对象的&…
阅读更多...
【JVM】JVM实战笔记-随笔

【JVM】JVM实战笔记-随笔

JVM实战笔记-随笔 前言字节码如何查看字节码文件jclasslibJavapArthasArthurs监控面板Arthus查看字节码信息 内存调优内存溢出的常见场景解决内存溢出发现问题Top命令VisualVMArthas使用案例 Prometheus Grafana案例 堆内存情况对比内存泄漏的原因:代码中的内存泄漏并发请求问…
阅读更多...
【Linux】Linux操作系统

【Linux】Linux操作系统

Linux基本指令 os概念与定位 本节内容&#xff1a; Linux操作系统讲解 os概念与定位 操作系统&#xff08;Operating System&#xff0c;简称OS&#xff09;是管理和控制计算机硬件与软件资源的计算机程序。总的来讲&#xff0c;操作系统是一款做软硬件管理的软件。 了解操作…
阅读更多...
IEC104初学者教程，第四章：IEC 104 开发环境搭建

IEC104初学者教程，第四章：IEC 104 开发环境搭建

第四章&#xff1a;IEC 104 开发环境搭建 文章目录 第四章&#xff1a;IEC 104 开发环境搭建IEC104从站模拟器的使用IEC104主站模拟器的使用 为了搭建开发环境&#xff0c;我们需要准备三款软件&#xff1a; 主站下载地址&#xff1a;IEC104主站模拟器从站下载地址&#xff1a;…
阅读更多...
设计模式使用场景实现示例及优缺点（行为型模式——命令模式）

设计模式使用场景实现示例及优缺点（行为型模式——命令模式）

从前&#xff0c;在一个美丽而神秘的王国里&#xff0c;住着一位智慧而仁慈的国王。他不仅以其公正和睿智著称&#xff0c;还因为他对知识的热爱和追求。他的王国繁荣昌盛&#xff0c;人们生活幸福安康。但即便如此&#xff0c;国王知道&#xff0c;要维持这种繁荣与和平&#…
阅读更多...
最新文章

Copyright @ 2022~2023