设计模式：组合模式（Composite）

最新推荐文章于 2024-08-01 13:23:41 发布

UestcXiye

最新推荐文章于 2024-08-01 13:23:41 发布

阅读量689

点赞数 20

分类专栏：设计模式文章标签：设计模式组合模式

本文链接：https://blog.csdn.net/ProgramNovice/article/details/138951858

版权

设计模式专栏收录该内容

19 篇文章 2 订阅

订阅专栏

设计模式：组合模式（Composite）

设计模式：组合模式（Composite）

设计模式：组合模式（Composite）

组合模式（Composite）属于结构型模式（Structural Pattern）的一种。

结构型模式（Structural Pattern）描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过简单积木的组合形成复杂的、功能更为强大的结构。

结构型模式可以分为类结构型模式和对象结构型模式：

类结构型模式关心类的组合，由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系。
对象结构型模式关心类与对象的组合，通过关联关系使得在一个类中定义另一个类的实例对象，然后通过该对象调用其方法。根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系，因此大部分结构型模式都是对象结构型模式。

模式动机

将对象组合成树状结构，并且能像使用独立对象一样使用它们。

模式定义

组合模式（Composite）别名为部分整体模式，属于对象结构型模式。

组合模式将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

模式结构

组合模式（Composite）包含如下角色：

组件（Component）：定义了组合中所有对象的通用接口，可以是抽象类或接口。它声明了用于访问和管理子组件的方法，包括添加、删除、获取子组件等。
叶子节点（Leaf）：表示组合中的叶子节点对象，叶子节点没有子节点。它实现了组件接口的方法。
复合节点（Composite）：又称为容器（Container），是包含叶节点或其他容器等子项目的单位。实现了对子部件的相关操作，⽐如添加、删除、获取子组件等。
客户端（Client）：通过组件接口与组合结构进行交互，客户端不需要区分叶子节点和复合节点，可以一致地对待整体和部分。

在这里插入图片描述

注意：

容器不知道其子项目所属的具体类，它只通过通用的组件接口与其子项目交互。
容器接收到请求后会将工作分配给自己的子项目，处理中间结果，然后将最终结果返回给客户端。

时序图

模式实现

组件 Component.h：

#ifndef _COMPONENT_H_
#define _COMPONENT_H_

class Component
{
public:
	virtual void execute() = 0;
};

#endif // !_COMPONENT_H_

叶子节点 Leaf.h：

#ifndef _LEAF_H_
#define _LEAF_H_

#include <iostream>

#include "Component.h"

class Leaf : public Component
{
public:
	virtual void execute()
	{
		std::cout << "Leaf::execute" << std::endl;
	}
};

#endif // !_LEAF_H_

复合节点 Composite.h：

#ifndef _COMPOSITE_H_
#define _COMPOSITE_H_

#include <iostream>
#include <list>

#include "Component.h"

class Composite : public Component
{
private:
	std::list<Component*> children;

public:
	void add(Component* component)
	{
		children.push_back(component);
	}
	void remove(Component* component)
	{
		children.remove(component);
	}
	std::list<Component*> getChildren()
	{
		return children;
	}
	virtual void execute()
	{
		std::cout << "Composite::execute" << std::endl;
		for (Component* child : children)
		{
			child->execute();
		}
	}
};

#endif // !_COMPOSITE_H_

在单线程环境下的测试

测试代码：

#include <stdlib.h>

#include "Component.h"
#include "Leaf.h"
#include "Composite.h"

int main()
{
	Leaf* leaf1 = new Leaf();
	Leaf* leaf2 = new Leaf();
	Leaf* leaf3 = new Leaf();
	Composite* c1 = new Composite();
	Leaf* leaf4 = new Leaf();
	Leaf* leaf5 = new Leaf();
	Composite* c2 = new Composite();

	c1->add(leaf1);
	c1->add(leaf2);
	c1->add(leaf3);
	c2->add(leaf4);
	c2->add(leaf5);
	c1->add(c2);
	c1->execute();

	delete leaf1;
	delete leaf2;
	delete leaf3;
	delete leaf4;
	delete leaf5;
	delete c1;
	delete c2;

	system("pause");
	return 0;
}

运行结果：

在这里插入图片描述

在多线程环境下的测试

略。

模式分析

组合模式通过一种巧妙的设计方案，可以一致性地处理整个树形结构或者树形结构的一部分，也可以一致性地处理树形结构中的叶子节点（不包含子节点的节点）和容器节点。
组合模式主要解决了在对象组合树中，如何实现一致性的操作和处理的问题。它使得用户可以方便地对对象树进行操作，而不需要考虑对象的具体类型。组合模式还提供了一种灵活的方式来表示对象结构，可以方便地添加和删除对象。

优缺点

优点：

通过组合模式，可以使客户端统一处理单个对象和组合对象，并且不用区分类型，简化了客户端代码的复杂性。
符合“开闭原则”：在无需修改现有的代码情况下，可以很容易地增减新的组件类型，更加灵活。
可以利用多态和递归机制更方便地使用复杂树结构。

缺点：

在使用组合模式时，其叶子和树枝的声明都是实现类，而不是接口，违反了依赖倒置原则。
对于功能差异较大的类，提供公共接口或许会有困难。在特定情况下，你需要过度一般化组件接口，使其变得令人难以理解。
组合模式引入了新的类和关系，增加了系统的复杂性。在一些简单的情况下，使用组合模式可能会显得过于繁琐。

适用场景

在以下情况下可以使用组合模式（Composite）：

如果你需要实现树状对象结构，可以使用组合模式。
组合模式为你提供了两种共享公共接口的基本元素类型：简单叶节点和复杂容器。容器中可以包含叶节点和其他容器。这使得你可以构建树状嵌套递归对象结构。
如果你希望客户端代码以相同方式处理简单和复杂元素，可以使用该模式。
组合模式中定义的所有元素共用同一个接口。在这一接口的帮助下，客户端不必在意其所使用的对象的具体类。

应用场景

算术表达式包括操作数、操作符和另一个操作数，其中，另一个操作数也可以是操作数、操作符和另一个操作数。
公司：一个公司下面有很多小部门，每个部门下面又分好几个组，有可能再细点每个组又分为职业不同的人（前端、测试、开发、运维）。
文件：比如C盘、D盘下面有很多文件夹，文件夹里面又有很多文件或文件夹。
HashMap：putAll()传入的是Map对象，Map就是一个组件，而HashMap就是一个组合节点，HashMap中的Node节点就是叶子节点。
Java AWT和SWING：对于Button和Checkbox是叶子节点，Container是组合节点。

应用实例

下面以算数表达式为例，解释一下组合模式。我们可以把算数表达式看作是一个树状结构，由操作符和操作数组成。

组件（Component）：Expression
叶子节点（Leaf）：AddOperator、SubOperator、MultOperator、DivideOperator、Number
组合节点（Composite）：Operator

UML 类图：

在这里插入图片描述

完整代码：

#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;

class Expression
{
public:
	virtual double evaluate() = 0;
};

class Number : public Expression
{
private:
	double val;

public:
	Number(double v) : val(v){};

	virtual double evaluate()
	{
		return val;
	}
};

class Operator : public Expression
{
protected:
	Expression *left;
	Expression *right;

public:
	Operator(Expression *l, Expression *r) : left(l), right(r){};
};

class AddOperator : public Operator
{
public:
	AddOperator(Expression *l, Expression *r) : Operator(l, r){};

	virtual double evaluate()
	{
		return left->evaluate() + right->evaluate();
	}
};

class SubOperator : public Operator
{
public:
	SubOperator(Expression *l, Expression *r) : Operator(l, r){};

	virtual double evaluate()
	{
		return left->evaluate() - right->evaluate();
	}
};

class MultOperator : public Operator
{
public:
	MultOperator(Expression *l, Expression *r) : Operator(l, r){};

	virtual double evaluate()
	{
		return left->evaluate() * right->evaluate();
	}
};

class DivideOperator : public Operator
{
public:
	DivideOperator(Expression *l, Expression *r) : Operator(l, r){};

	virtual double evaluate()
	{
		if (right->evaluate())
			return left->evaluate() / right->evaluate();
		else
			return -1;
	}
};

int main()
{
	// 构建一个算数表达式: (2 + 3) * 4 - 20 / 5
	Expression *expression = new SubOperator(
		new MultOperator(
			new AddOperator(new Number(2), new Number(3)), new Number(4)),
		new DivideOperator(new Number(20), new Number(5)));

	// 计算表达式的结果
	double result = expression->evaluate();
	cout << "(2 + 3) * 4 - 20 / 5 = " << result << endl;

	system("pause");
	return 0;
}