[设计模式/Java] 设计模式之组合模式(部分-整体模式)【19】

概述: 组合模式(Composite Pattern):= 部分-整体模式(Part-Whole Pattern)

场景引入

场景1：文件系统的目录层次结构

  • 我们对于这个图片肯定会非常熟悉，这两幅图片我们都可以看做是一个文件结构，对于这样的结构我们称之为树形结构。
  • 在数据结构中我们了解到可以通过调用某个方法来遍历整个树，当我们找到某个叶子节点的时候，就可以对叶子节点进行相关的操作。
    我们可以将这颗树理解成一个大的容器，容器里面包含很多的成员对象，这些对象即可以是容器对象也可以是叶子对象。
  • 但是由于容器对象和叶子对象在功能上的区别，使得我们在使用的过程中【必须要区分】容器对象和叶子对象，但是这样就会给客户带来不必要的麻烦。

作为客户，它希望能够一致地对待容器对象和叶子对象。

这就是组合模式的设计动机：组合模式定义了如何将【容器对象】和【叶子对象】进行【递归组合】，使得客户在使用的过程中无需区分，可以对它们进行一致的处理。

场景2：部分与整体的关系（电脑与零部件）

  • 电脑与其零件也是部分-整体关系

模式定义

  • 组合模式（Composite Pattern） 也称为 整体-部分（Part-Whole）模式。

    • 它的宗旨是通过将单个对象（叶子节点）和组合对象（树枝节点）用相同的接口进行表示，使得客户对单个对象和组合对象的使用具有一致性。
    • 用于把一组【相似的对象】当做一个【单一的对象】。
    • 组合模式依据树形结构来组合对象，用来表示部分以及整体层次。

  • 组合模式

    • 一般用来描述 整体 与 部分 的关系，它将对象组织到树形结构中：
      • 最顶层的节点称为 根节点
      • 根节点下面可以包含 树枝节点 和 叶子节点
      • 树枝节点下面又可以包含 树枝节点 和 叶子节点。
    • 组合模式对单个对象(叶子对象)和组合对象(组合对象)具有一致性，它将对象组合到树结构中，可以用来描述整体和部分的关系。
    • 同时，它也模糊了简单元素(叶子对象)和复杂元素(容器对象)的概念，使得客户能够像处理简单元素一样来处理复杂元素，从而使得客户程序能够与复杂元素的内部结构解耦。

  • 模式的分类。

    • 这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。
    • 这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

由上图可见：

  • 其实根节点和树枝节点本质上是同一种数据类型（蓝色圆圈），可以作为容器使用；
  • 而叶子节点与树枝节点在语义上不属于同一种类型，但是在组合模式 中，会把树枝节点和叶子节点认为是同一种数据类型（用同一接口定义），让它们具备一致行为
  • 这样，在组合模式中，整个树形结构中的对象都是同一种类型，带来的一个好处就是客户无需辨别 树枝节点 还是 叶子节点，而是可以直接进行操作，给客户使用带来极大的便利。

比如说，计算机的文件系统，文件系统由文件和目录组成，目录下面也可以包含文件或者目录，计算机的文件系统是用递归结构来进行组织的，对于这样的数据结构是非常适用使用组合模式的。

  • 组合模式的核心：借助同一接口，使叶子节点和树枝节点的操作具备一致性。

    • 在使用组合模式中需要注意一点也是组合模式最关键的地方：叶子对象和组合对象实现相同的接口。

    • 这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。

模式的组成

组合模式角色：

  • 抽象根节点（Component）
    • 作为组合中对象声明接口，实现所有类共有接口的默认行为。
  • 树枝节点（Composite）
    • 定义有子部件的组合部件行为，存储子部件（组合树枝节点和叶子节点形成一个树形结构；）
    • 在Component接口中实现与子部件有关的操作。
  • 叶子节点（Leaf）
    • 叶子节点对象，其下再无分支，是系统层次遍历的最小单位；
  • 客户端(Client)：
    • 使用 Component 部件的对象。

透明组合模式

  • 透明模式：把组合（树节点）使用的方法放到统一行为（Component）中，让不同层次（树节点，叶子节点）的结构都具备一致行为

其 UML 类图如下所示：

透明组合模式: 把所有公共方法都定义在 Component 中：

  • 好处:
  • 客户端无需分辨是叶子节点（Leaf）和树枝节点（Composite），它们具备完全一致的接口；
  • 缺点:
  • 叶子节点（Leaf）会继承得到一些它所不需要（管理子类操作的方法）的方法，这与设计模式 接口隔离原则 相违背。

解决方法：透明组合模式 中，由于 Component 包含叶子节点所不需要的方法。因此，我们直接将这些方法默认抛出UnsupportedOperationException异常。

安全组合模式

  • 安全组合模式：统一行为（Component）只规定系统各个层次的最基础的一致行为，而把组合（树节点）本身的方法（管理子类对象的添加，删除等）放到自身当中

其 UML 类图如下所示：

  • 安全组合模式：
  • 把系统各层次公有的行为定义在 Component 中，把组合（树节点）的特有行为（管理子类增加，删除等）放到自身（Composite）中。
  • 好处
  • 接口定义职责清晰，符合设计模式 单一职责原则 和 接口隔离原则；
  • 缺点
  • 客户需要区分树枝节点（Composite）和叶子节点（Leaf）

这样才能正确处理各个层次的操作，客户端无法依赖抽象（Component），违背了设计模式依赖倒置原则。

案例实践

CASE 树形结构

#include<iostream>
#include  <memory>
#include <list>
using namespace std;
class Componet;

typedef shared_ptr<Componet> COMPONET;

//Component 公共类
class Componet {
public:
    explicit Componet(string & _name) : name(_name){}
    virtual ~Componet() {  };
    virtual void Add(COMPONET c) = 0;
    virtual void Remove(COMPONET c) = 0;
    virtual void Display(int depth){
        for (int i = 0; i < depth; i++)
            cout << "-";
        cout << name << endl;
    }
protected:
    std::string name;
};



//Leaf 叶子
class Leaf : public Componet{
public:
    explicit Leaf(std::string _name) : Componet(_name){}
    ~Leaf() override= default;;

    void Remove(COMPONET c) override {
        throw "Cannot remove from a leaf";
    }

    void Add(COMPONET c) override{
        throw "Cannot add to a leaf";
    }
};


//Composite 组合
class Composite : public Componet{
	public:
		Composite(string _name) : Componet(_name) {}
		~Composite() {}

		void Add(COMPONET c) override {
			children.push_back(c);
		}
		void Remove(COMPONET c) override{
			children.remove(c);
		}

		void Display(int depth) override {
			Componet::Display(depth);
			for (const auto& itr : children)
			{
				itr->Display(depth + 3);
			}
		}

	private:
		std::list<COMPONET> children;
};


//main 方法
int main(int argc,char **argv){
	//建立根
	COMPONET root(new Composite(std::string("root")));

	//添加两片叶子到根
	root->Add(COMPONET(new Leaf(std::string("Leaf A"))));
	root->Add(COMPONET(new Leaf(std::string("Leaf B"))));


	//创建分支
	COMPONET compositeX(new Composite(string("composite X")));
	compositeX->Add(COMPONET(new Leaf(std::string("Leaf A"))));
	compositeX->Add(COMPONET(new Leaf(std::string("Leaf B"))));
	//分支挂在根上
	root->Add(compositeX);

	//创建分支
	COMPONET compositeY(new Composite(string("composite Y")));
	compositeY->Add(COMPONET(new Leaf(std::string("Leaf A"))));
	compositeY->Add(COMPONET(new Leaf(std::string("Leaf B"))));
	//分支挂在另一个分支上
	compositeX->Add(compositeY);

	root->Add(COMPONET(new Leaf(std::string("Leaf C"))));

	COMPONET leaf(new Leaf(string("Leaf D")));
	root->Add(leaf);//添加叶子
	root->Remove(leaf);//移除叶子

	//显示树形结构
	root->Display(1);

	return 0;
}

out

-root
----Leaf A
----Leaf B
----composite X
-------Leaf A
-------Leaf B
-------composite Y
----------Leaf A
----------Leaf B
----Leaf C

CASE 职工: 职工及下属职工

  • 场景描述
  • 我们有一个类 Employee，该类被当作组合模型类。
  • CompositePatternDemo 类使用 Employee 类来添加部门层次结构，并打印所有员工。

  • step1 创建 Employee 类，该类带有 Employee 对象的列表。
  • Employee
import java.util.ArrayList;
import java.util.List;
 
public class Employee {
   private String name;
   private String dept;
   private int salary;
   private List<Employee> subordinates;
 
   //构造函数
   public Employee(String name,String dept, int sal) {
      this.name = name;
      this.dept = dept;
      this.salary = sal;
      subordinates = new ArrayList<Employee>();
   }
 
   public void add(Employee e) {
      subordinates.add(e);
   }
 
   public void remove(Employee e) {
      subordinates.remove(e);
   }
 
   public List<Employee> getSubordinates(){
     return subordinates;
   }
 
   public String toString(){
      return ("Employee :[ Name : "+ name 
      +", dept : "+ dept + ", salary :"
      + salary+" ]");
   }   
}
  • step2 使用 Employee 类来创建和打印员工的层次结构。
  • CompositePatternDemo
public class CompositePatternDemo {
   public static void main(String[] args) {
      Employee CEO = new Employee("John","CEO", 30000);
 
      Employee headSales = new Employee("Robert","Head Sales", 20000);
 
      Employee headMarketing = new Employee("Michel","Head Marketing", 20000);
 
      Employee clerk1 = new Employee("Laura","Marketing", 10000);
      Employee clerk2 = new Employee("Bob","Marketing", 10000);
 
      Employee salesExecutive1 = new Employee("Richard","Sales", 10000);
      Employee salesExecutive2 = new Employee("Rob","Sales", 10000);
 
      CEO.add(headSales);
      CEO.add(headMarketing);
 
      headSales.add(salesExecutive1);
      headSales.add(salesExecutive2);
 
      headMarketing.add(clerk1);
      headMarketing.add(clerk2);
 
      //打印该组织的所有员工
      System.out.println(CEO); 
      for (Employee headEmployee : CEO.getSubordinates()) {
         System.out.println(headEmployee);
         for (Employee employee : headEmployee.getSubordinates()) {
            System.out.println(employee);
         }
      }        
   }
}

out

Employee :[ Name : John, dept : CEO, salary :30000 ]
Employee :[ Name : Robert, dept : Head Sales, salary :20000 ]
Employee :[ Name : Richard, dept : Sales, salary :10000 ]
Employee :[ Name : Rob, dept : Sales, salary :10000 ]
Employee :[ Name : Michel, dept : Head Marketing, salary :20000 ]
Employee :[ Name : Laura, dept : Marketing, salary :10000 ]
Employee :[ Name : Bob, dept : Marketing, salary :10000 ]

CASE 电脑与零部件

  • 电脑型号A与各个零件，电脑型号B与各个零件

CASE 总公司、分/子公司、部分之间的关系

CASE 算术表达式

  • 算术表达式：构建一个由操作数、操作符和子表达式组成的树形结构。

CASE GUI: 容器组件与子组件

  • GUI组件：在Java的AWT和Swing库中，容器（如Panel）可以包含其他组件（如按钮和复选框）。

CASE 文件系统

  • 浏览文件。 在文件系统中，可能存在很多种格式的文件，如果图片，文本文件、视频文件等等，这些不同的格式文件的浏览方式都不同，同时对文件夹的浏览就是对文件夹中文件的浏览，但是对于客户而言都是浏览文件，两者之间不存在什么差别，现在可用组合模式来模拟浏览文件。

  • 复制文件：一个个复制，或者整个文件夹复制

  • 文本编辑：对单个字操作/整段文字操作

H FAQ

Q： 透明组合模式 和 安全组合模式 都有各自的优点和缺点，那么我们应该优先选择哪一种呢？

  • 答：既然 组合模式 会被分为两种实现，那么肯定是不同的场合某一种会更加适合

即: 具体情况具体分析。

  • 透明组合模式 将公共接口封装到抽象根节点（Component）中，那么系统所有节点就具备一致行为，所以如果当系统绝大多数层次具备相同的公共行为时，采用 透明组合模式，也许会更好（代价：为剩下少数层次节点引入不需要的方法）；

  • 而如果当系统各个层次差异性行为较多或者树节点层次相对稳定（健壮）时，采用安全组合模式

Y 推荐文献

X 参考文献

posted @ 2025-04-22 09:50  千千寰宇  阅读(81)  评论(0)    收藏  举报