组合模式（Composite Pattern）

已于 2025-04-22 21:37:59 修改
阅读量845 收藏 14
点赞数 20
分类专栏： 设计模式 文章标签： 组合模式
于 2024-10-08 23:37:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45136016/article/details/142771096
版权

文章目录

0.写在前面的话

我创建的Unity、C#交流群，有兴趣可加入大家一起学习（现在人还很少，现在加入就是元老🙀）：952914223

1.组合模式

1.1 定义

将对象组合成树形结构来表现”部分-整体“的层次结构，使得客户以一致的方式处理单个对象以及对象的组合。
在这里插入图片描述

1.2 使用场景

在软件开发过程中，我们经常会遇到处理简单对象和复合对象的情况，例如对操作系统中目录的处理就是这样的一个例子，因为目录可以包括单独的文件，也可以包括文件夹，文件夹又是由文件组成的，由于简单对象和复合对象在功能上区别，导致在操作过程中必须区分简单对象和复合对象，这样就会导致客户调用带来不必要的麻烦，然而作为客户，它们希望能够始终一致地对待简单对象和复合对象。然而组合模式就是解决这样的问题。下面让我们看看组合模式是怎样解决这个问题的。

2.组合模式结构

在这里插入图片描述

  • 组件（Component）：接口描述了树中简单项目和复杂项目所共有的操作。
  • 叶节点（Leaf）：是树的基本结构， 它不包含子项目。一般情况下， 叶节点最终会完成大部分的实际工作， 因为它们无法将工作指派给其他部分。
  • 容器（Container）：——又名 “组合 （Composite）”——是包含叶节点或其他容器等子项目的单位。 容器不知道其子项目所属的具体类， 它只通过通用的组件接口与其子项目交互。容器接收到请求后会将工作分配给自己的子项目， 处理中间结果， 然后将最终结果返回给客户端。
  • 客户端（Client） ：通过组件接口与所有项目交互。 因此， 客户端能以相同方式与树状结构中的简单或复杂项目交互。

3.UML类图

3.1 透明式的组合模式类图

在这里插入图片描述

3.2 安全式组合模式的类图

在这里插入图片描述

4.具体实现

4.1 透明式的组合模式

组件（Component）:

/// <summary>
/// 图形抽象类
/// </summary>
public abstract class Graphics
{
    public string Name {get; set;}
    public Graphics(string name)
    {
        Name = name;
    }

    public abstract void Draw();
    public abstract void Add(Graphics graphics);
    public abstract void Remove(Graphics graphics);
}

叶节点（Leaf）:

/// <summary>
/// 简单图形类——线
/// </summary>
public class Line : Graphics
{
    public Line(string name) : base(name)
    { }

    // 重写父类抽象方法
    public override void Draw()
    {
        Console.WriteLine("画  " + Name);
    }

    // 因为简单图形在添加或移除其他图形，所以简单图形Add或Remove方法没有任何意义
    // 如果客户端调用了简单图形的Add或Remove方法将会在运行时抛出异常
    // 我们可以在客户端捕获该类移除并处理
    public override void Add(Graphics graphics)
    {
        throw new Exception("不能向简单图形Line添加其他图形");
    }

    public override void Remove(Graphics graphics)
    {
        throw new Exception("不能向简单图形Line移除其他图形");
    }
}

/// <summary>
/// 简单图形类——圆
/// </summary>
public class Circle : Graphics
{
    public Circle(string name)
        : base(name)
    { }

    // 重写父类抽象方法
    public override void Draw()
    {
        Console.WriteLine("画  " + Name);
    }

    public override void Add(Graphics g)
    {
        throw new Exception("不能向简单图形Circle添加其他图形");
    }
    public override void Remove(Graphics g)
    {
        throw new Exception("不能向简单图形Circle移除其他图形");
    }
}

容器（Container）:

/// <summary>
/// 复杂图形，由一些简单图形组成,这里假设该复杂图形由一个圆两条线组成的复杂图形
/// </summary>
public class ComplexGraphics : Graphics
{
    private List<Graphics> complexGraphicsList = new List<Graphics>();

    public ComplexGraphics(string name)
        : base(name)
    { }

    /// <summary>
    /// 复杂图形的画法
    /// </summary>
    public override void Draw()
    {          
        foreach (Graphics g in complexGraphicsList)
        {
            g.Draw();
        }
    }

    public override void Add(Graphics g)
    {
        complexGraphicsList.Add(g);
    }
    public override void Remove(Graphics g)
    {
        complexGraphicsList.Remove(g);
    }
}

客户端（Client） :

ComplexGraphics complexGraphics = new ComplexGraphics("一个复杂图形和两条线段组成的复杂图形");
complexGraphics.Add(new Line("线段A"));
 ComplexGraphics CompositeCG = new ComplexGraphics("一个圆和一条线组成的复杂图形");
 CompositeCG.Add(new Circle("圆"));
 CompositeCG.Add(new Circle("线段B"));
 complexGraphics.Add(CompositeCG);
 Line l = new Line("线段C");
 complexGraphics.Add(l);

 // 显示复杂图形的画法
 Console.WriteLine("复杂图形的绘制如下：");
 complexGraphics.Draw();
 Console.WriteLine("复杂图形绘制完成");
 Console.WriteLine();

 // 移除一个组件再显示复杂图形的画法
 complexGraphics.Remove(l);
 Console.WriteLine("移除线段C后，复杂图形的绘制如下：");
 complexGraphics.Draw();
 Console.WriteLine("复杂图形绘制完成");

复杂图形的绘制如下：
画 线段A
画 圆
画 线段B
画 线段C
复杂图形绘制完成
移除线段C后，复杂图形的绘制如下：
画 线段A
画 圆
画 线段B
复杂图形绘制完成

4.2 安全式组合模式

此方式实现的组合模式把管理子对象的方法声明在树枝构件ComplexGraphics类中

/// 此方式实现的组合模式把管理子对象的方法声明在树枝构件ComplexGraphics类中
/// 这样如果叶子节点Line、Circle使用了Add或Remove方法时，就能在编译期间出现错误
/// 但这种方式虽然解决了透明式组合模式的问题，但是它使得叶子节点和树枝构件具有不一样的接口。
/// 所以这两种方式实现的组合模式各有优缺点，具体使用哪个，可以根据问题的实际情况而定
class Client
{
    static void Main(string[] args)
    {
        ComplexGraphics complexGraphics = new ComplexGraphics("一个复杂图形和两条线段组成的复杂图形");
        complexGraphics.Add(new Line("线段A"));
        ComplexGraphics CompositeCG = new ComplexGraphics("一个圆和一条线组成的复杂图形");
        CompositeCG.Add(new Circle("圆"));
        CompositeCG.Add(new Circle("线段B"));
        complexGraphics.Add(CompositeCG);
        Line l = new Line("线段C");
        complexGraphics.Add(l);

        // 显示复杂图形的画法
        Console.WriteLine("复杂图形的绘制如下：");
        Console.WriteLine("---------------------");
        complexGraphics.Draw();
        Console.WriteLine("复杂图形绘制完成");
        Console.WriteLine("---------------------");
        Console.WriteLine();

        // 移除一个组件再显示复杂图形的画法
        complexGraphics.Remove(l);
        Console.WriteLine("移除线段C后，复杂图形的绘制如下：");
        Console.WriteLine("---------------------");
        complexGraphics.Draw();
        Console.WriteLine("复杂图形绘制完成");
        Console.WriteLine("---------------------");
        Console.Read();
    }
}

/// <summary>
/// 图形抽象类，
/// </summary>
public abstract class Graphics
{
    public string Name { get; set; }
    public Graphics(string name)
    {
        this.Name = name;
    }

    public abstract void Draw();
    // 移除了Add和Remove方法
    // 把管理子对象的方法放到了ComplexGraphics类中进行管理
    // 因为这些方法只在复杂图形中才有意义
}

/// <summary>
/// 简单图形类——线
/// </summary>
public class Line : Graphics
{
    public Line(string name)
        : base(name)
    { }

    // 重写父类抽象方法
    public override void Draw()
    {
        Console.WriteLine("画  " + Name);
    }
}

/// <summary>
/// 简单图形类——圆
/// </summary>
public class Circle : Graphics
{
    public Circle(string name)
        : base(name)
    { }

    // 重写父类抽象方法
    public override void Draw()
    {
        Console.WriteLine("画  " + Name);
    }
}

/// <summary>
/// 复杂图形，由一些简单图形组成,这里假设该复杂图形由一个圆两条线组成的复杂图形
/// </summary>
public class ComplexGraphics : Graphics
{
    private List<Graphics> complexGraphicsList = new List<Graphics>();
    public ComplexGraphics(string name)
        : base(name)
    { }

    /// <summary>
    /// 复杂图形的画法
    /// </summary>
    public override void Draw()
    {
        foreach (Graphics g in complexGraphicsList)
        {
            g.Draw();
        }
    }

    public void Add(Graphics g)
    {
        complexGraphicsList.Add(g);
    }
    public void Remove(Graphics g)
    {
        complexGraphicsList.Remove(g);
    }
}
UML——Unified modeling language UML (统一建模语言)
qq_44891295的博客
01-14 916
文章目录1： UML基本介绍2： UML图3： UML类图3.1 类图—依赖关系（Dependence）3.2 类图—泛化关系(generalization）3.3 类图—实现关系（Implementation）3.4 类图—关联关系（Association）3.5 类图—聚合关系（Aggregation）3.6 类图—组合关系（Composition） 1： UML基本介绍 UML——Unif...
设计模式 17 组合模式 Composite Pattern
jxusthusiwen的专栏
05-26 1185
组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。它允许你将对象组合成树形结构，以表示“部分-整体”层次关系。
组合模式（Composite Pattern）原理图
04-11
组合模式（Composite Pattern）是一种对象结构型模式，其定义是将多个对象组合成树形结构以表示“整体-部分”关系的层次结构。它使得客户端对单个对象和组合对象的使用具有一致性。在组合模式中，对象被组织成树形结构，其中顶层的节点被称为根节点，根节点下面可以包含树枝节点和叶子节点，树枝节点下面又可以包含更多的树枝节点和叶子节点。这种结构使得客户端可以统一地处理单个对象和组合对象，无需关心它们的具体类型。 组合模式的主要优点包括： 简化了客户端代码，客户端可以一致地处理单个对象和组合对象，无需进行类型判断。 更容易在组合体内加入新的对象，客户端不会因为加入了新的对象而更改源代码，满足“开闭原则”。 然而，组合模式也存在一些缺点，如设计较复杂，客户端需要花更多时间理清类之间的层次关系；不容易限制容器中的构件；不容易用继承的方法来增加构件的新功能等。
设计模式--组合模式
weixin_30721077的博客
07-21 60
原文链接 http://blog.jobbole.com/78079/ 理解模型：复杂图形对象，线段对象，圆对象，都可以使用复杂图形对象来统一调用、管理 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; ...
23种设计模式之组合模式
最新发布
分享技术应用、实践场景等，评论区开放技术难题讨论，共同成长进步。
04-19 347
组合模式在 Java 标准库中广泛应用，如 Swing 的 JComponent 和 AWT 的 Container。掌握该模式能有效处理复杂层次结构，提升代码可维护性。
组合模式
weixin_30439031的博客
01-29 86
考虑实现一个管理公司组织架构的系统，公司下可能包含子公司，子公司下包含CEO等最高管理者和部门，部门下又包含部门管理者和小部门，等等。抽象成数据结构，就是一个树形结构。 　　 如果为每一种尸体类型都定义一个类，那至少要包括总公司/子公司/部门/员工，这四个类。每个类的所包含的成员也有很大不同，均需要定制。而且随着类型越来越多，这种组合性的复杂的是成指数上升的。 上...
组合模式 Composite Pattern
03-09
**组合模式**(Composite Pattern)是一种常用的结构型设计模式，主要用于构建具有层次结构的对象系统。它允许客户端以一致的方式处理单个对象和组合对象，简化了高层模块的调用。通过组合模式，可以将多个对象组织成...
c++-设计模式之组合模式（Composite Pattern）
09-19
组合模式（Composite Pattern）是一种结构型设计模式，用于将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户端可以以统一的方式对待单个对象和组合对象，这种模式常用于需要处理树形结构的数据...
组合模式（Composite Pattern）C++
yaoyaohyl的博客
02-28 1160
这体现了组合模式的强大之处：客户代码可以以统一的方式处理单个对象和组合对象，从而简化了客户代码的复杂度。我们希望设计一个系统，允许角色装备单个物品或物品的组合，同时能够统一处理这些物品或物品组合。组合模式使得客户端通过一个统一的接口操作单个对象和组合对象，这简化了客户端的使用，同时支持树形结构的复杂性管理。在游戏开发中，组合模式可以用于表示游戏中的菜单系统、UI组件层次、游戏角色的装备系统等，其中每个部分既可以是一个单一对象，也可以是一个由多个对象组成的复合对象。Composite（组合组件）
组合模式（Composite Pattern ）
系统运维
12-31 299
当我想去了解组合模式的时候，网上搜一下，有很多优秀的文章，但很多人都在直接给出了组合模式的UML图，然后就去讲解什么是组合，组合有什么优缺点。 我承认他们也许讲的很好，但我并没有一下子就能理解了组合模式，也不了解文章所说的优缺点；结合自己的感受，所以在这里，我想 把书上看到的UML类图变化，和大家分享一下，看看组合模式是怎么一步一步演变出来的。这样，以后开发就知道自己在做哪一步了， 该怎...
奶茶小料的组合模式类图
12-30
### 设计模式中的奶茶小料组合 在面向对象编程中，通过应用装饰器模式可以灵活地给奶茶添加不同的小料而不改变其原有代码结构。基于此需求，下面展示了一个简化版的UML类图来表示如何利用装饰器模式实现奶茶及其附加的小料组件。 #### UML 类图描述 ```plaintext +-----+ ^ | +-------------------+ | ConcreteMilkTea |----> 实现基础奶茶逻辑 +-------------------+ | -process():void | +-------------------+ +-------------------+ | Decorator | -----> 抽象装饰者角色, 继承自MilkTea +-------------------+ | -milktea:MilkTea| | -process() | +-------------------+ ^ | +-------------------+ | CondimentDecorator| ---> 小料的具体实现，比如珍珠、椰果等 +-------------------+ | -specificProcess()| | -process():void | +-------------------+ ``` 在这个图表里： - `MilkTea` 是一个抽象基类，定义了所有具体奶茶以及它们可能拥有的任何装饰者的公共接口。 - `ConcreteMilkTea` 表示具体的奶茶产品，实现了由父类声明的方法[^1]。 - `Decorator` 定义了一种动态增加职责的方式；它维持着对实际奶茶实例(`MilkTea`) 的引用，并提供与被修饰的对象相同的接口以便于透明地使用这些对象。 - `CondimentDecorator` 扩展了基本的装饰者行为，允许向特定类型的奶茶上追加额外的功能特性——即各种各样的小料选项[^2]。 为了更直观理解上述关系，在Java语言环境下可参照如下代码片段模拟这一过程: ```java // 基础奶茶类 abstract class MilkTea { public abstract void process(); } class OriginalMilkTea extends MilkTea{ @Override public void process(){ System.out.println("准备一杯原味奶茶"); } } // 装饰者基类 abstract class CondimentDecorator extends MilkTea { protected MilkTea milkTea; public CondimentDecorator(MilkTea mt){ this.milkTea = mt; } // 子类需重写此方法以加入各自特色加工流程 public abstract void specificProcess(); @Override public final void process(){ milkTea.process(); // 首先执行原始奶茶制备步骤 specificProcess(); // 接着进行特有处理（如添加配料） } } // 特定小料实现之一：珍珠 class PearlyBeads extends CondimentDecorator { public PearlyBeads(MilkTea mt){ super(mt); } @Override public void specificProcess(){ System.out.println("...再加入Q弹珍珠..."); } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值