Java结构型设计模式之组合模式Composite Pattern详解

目录

概述三大组件应用案例

顶层组件OrganizationComponentComposite组件叶子节点客户端测试UML类图总结

概述

组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“整体-部分”的层次关系。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。
这种类型的设计模式属于结构型模式。
组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象。

三大组件

Component :这是组合中对象声明接口，在适当情况下，实现所有类共有的接口默认行为,用于访问和管理Component 子部件, Component 可以是抽象类或者接口
Leaf : 在组合中表示叶子节点，叶子节点没有子节点，其定义组合内元素的行为。
Composite :非叶子节点， 用于存储子部件， 在Component 接口中实现子部件的相关操作，比如增加(add),删除，但是可能没有子结点（组件元素）行为。

应用案例

编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。

传统方案可能按照 学校-学院-系别处理。将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系， 因此这种方案，不能很好实现的管理的操作，比如对学院、系的添加，删除，遍历等
解决方案：把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作 => 组合模式。

顶层组件OrganizationComponent

1. public abstract class OrganizationComponent {
2.         private String name; // 名字
3.         private String des; // 说明
4.         protected  void add(OrganizationComponent organizationComponent) {
5.                 //默认实现
6.                 throw new UnsupportedOperationException();
7.         }
8.         protected  void remove(OrganizationComponent organizationComponent) {
9.                 //默认实现
10.                 throw new UnsupportedOperationException();
11.         }
12.         //构造器
13.         public OrganizationComponent(String name, String des) {
14.                 super();
15.                 this.name = name;
16.                 this.des = des;
17.         }
18.         public String getName() {
19.                 return name;
20.         }
21.         public void setName(String name) {
22.                 this.name = name;
23.         }
24.         public String getDes() {
25.                 return des;
26.         public void setDes(String des) {
27.                 this.des = des;
28.         }
29.         //方法print, 做成抽象的, 子类都需要实现
30.         protected abstract void print();
31. }

复制代码

Composite组件

1. //University 就是 Composite , 可以管理College
2. public class University extends OrganizationComponent {
3.         List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
4.         // 构造器
5.         public University(String name, String des) {
6.                 super(name, des);
7.         }
8.         // 重写add
9.         @Override
10.         protected void add(OrganizationComponent organizationComponent) {
11.                 organizationComponents.add(organizationComponent);
12.         }
13.         // 重写remove
14.         @Override
15.         protected void remove(OrganizationComponent organizationComponent) {
16.                 organizationComponents.remove(organizationComponent);
17.         }
18.         @Override
19.         public String getName() {
20.                 return super.getName();
21.         }
22.         @Override
23.         public String getDes() {
24.                 return super.getDes();
25.         }
26.         // print方法，就是输出University 包含的学院
27.         @Override
28.         protected void print() {
29.                 System.out.println("--------------" + getName() + "--------------");
30.                 //遍历 organizationComponents
31.                 for (OrganizationComponent organizationComponent : organizationComponents) {
32.                         organizationComponent.print();
33.                 }
34.         }
35. }
36. // 可以管理Department
37. public class College extends OrganizationComponent {
38.         //List 中 存放的Department
39.         List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
40.         // 构造器
41.         public College(String name, String des) {
42.                 super(name, des);
43.         }
44.         // 重写add
45.         @Override
46.         protected void add(OrganizationComponent organizationComponent) {
47.                 //  将来实际业务中，Colleage 的 add 和  University add 不一定完全一样
48.                 organizationComponents.add(organizationComponent);
49.         }
50.         // 重写remove
51.         @Override
52.         protected void remove(OrganizationComponent organizationComponent) {
53.                 organizationComponents.remove(organizationComponent);
54.         }
55.         @Override
56.         public String getName() {
57.                 return super.getName();
58.         }
59.         @Override
60.         public String getDes() {
61.                 return super.getDes();
62.         }
63.         // print方法，就是输出University 包含的学院
64.         @Override
65.         protected void print() {
66.                 System.out.println("--------------" + getName() + "--------------");
67.                 //遍历 organizationComponents
68.                 for (OrganizationComponent organizationComponent : organizationComponents) {
69.                         organizationComponent.print();
70.                 }
71.         }
72. }

复制代码

叶子节点

1. public class Department extends OrganizationComponent {
2.         //没有集合
3.         public Department(String name, String des) {
4.                 super(name, des);
5.         }
6.         //add , remove 就不用写了，因为他是叶子节点
7.         @Override
8.         public String getName() {
9.                 return super.getName();
10.         }
11.         @Override
12.         public String getDes() {
13.                 return super.getDes();
14.         }
15.         @Override
16.         protected void print() {
17.                 System.out.println(getName());
18.         }
19. }

复制代码

客户端测试

1. public class Client {
2.         public static void main(String[] args) {
3.                 //从大到小创建对象 学校
4.                 OrganizationComponent university = new University("清华大学", " 中国顶级大学 ");
5.                 //创建 学院
6.                 OrganizationComponent computerCollege = new College("计算机学院", " 计算机学院 ");
7.                 OrganizationComponent infoEngineercollege = new College("信息工程学院", " 信息工程学院 ");
8.                 //创建各个学院下面的系(专业)
9.                 computerCollege.add(new Department("软件工程", " 软件工程不错 "));
10.                 computerCollege.add(new Department("网络工程", " 网络工程不错 "));
11.                 computerCollege.add(new Department("计算机科学与技术", " 计算机科学与技术是老牌的专业 "));
12.                 infoEngineercollege.add(new Department("通信工程", " 通信工程不好学 "));
13.                 infoEngineercollege.add(new Department("信息工程", " 信息工程好学 "));
14.                 //将学院加入到 学校
15.                 university.add(computerCollege);
16.                 university.add(infoEngineercollege);
17.                 //university.print();
18.                 infoEngineercollege.print();
19.         }
20. }

复制代码

UML类图

总结

组合模式可以简化客户端操作。客户端只需要面对一致的对象而不用考虑整体部分或者节点叶子的问题。
具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动。
方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构。
需要遍历组织机构，或者处理的对象具有树形结构时, 非常适合使用组合模式.
要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式。
Java 的集合类-HashMap 就使用了组合模式。
到此这篇关于Java结构型设计模式之组合模式Composite Pattern详解的文章就介绍到这了,更多相关Java Composite Pattern内容请搜索中国红客联盟以前的文章或继续浏览下面的相关文章希望大家以后多多支持中国红客联盟！