组合模式(结构型)
引入问题基本介绍代码实操
传统方案解决学校院系注意事项 JDK中的HashMap
组合模式(结构型) 引入问题 基本介绍 代码实操 传统方案解决学校院系分析：
将学院看作是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的。实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好地实现管理的操作，比如对学院、系的添加、删除、遍历等。解决方案：把学校、院、系都看作是组织结构 ，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作（组合模式）
1public abstract class OrganizationComponent {
2
3 private String name;//名字
4
5 private String des;//描述
6
7 public OrganizationComponent(String name, String des) {
8 this.name = name;
9 this.des = des;
10 }
11
//默认实现，这样子类就不需要全都重写了
12 protected void add(OrganizationComponent organizationComponent) {
13 //默认实现
14 throw new UnsupportedOperationException();
15 }
16
17 protected void remove(OrganizationComponent organizationComponent) {
18 //默认实现
19 throw new UnsupportedOperationException();
20 }
21 //抽象方法需要全部重写
22 protected abstract void print();
23
24
25 public String getName() {
26 return name;
27 }
28
29 public void setName(String name) {
30 this.name = name;
31 }
32
33 public String getDes() {
34 return des;
35 }
36
37 public void setDes(String des) {
38 this.des = des;
39 }
40}
1//University就是 Composite，可以管理College
2public class University extends OrganizationComponent {
3 4 List organizationComponents = new ArrayList();
5
6 public University(String name, String des) {
7 super(name, des);
8 }
9
10 @Override//重写
11 protected void add(OrganizationComponent organizationComponent) {
12 organizationComponents.add(organizationComponent);
13 }
14
15 @Override//重写
16 protected void remove(OrganizationComponent organizationComponent) {
17 organizationComponents.remove(organizationComponent);
18 }
19
20 @Override//重写
21 public String getName() {
22 return super.getName();
23 }
24
25 @Override//重写
26 public String getDes() {
27 return super.getDes();
28 }
29
30 @Override
31 protected void print() {
32 System.out.println("---------------" + getName() + "-------------------");
33 for (OrganizationComponent organizationComponent : organizationComponents) {
34 organizationComponent.print();
35 }
36 }
37}
1public class College extends OrganizationComponent {
2
3 List organizationComponents = new ArrayList();
4
5 public College(String name, String des) {
6 super(name, des);
7 }
8
9 @Override//重写
10 protected void add(OrganizationComponent organizationComponent) {
11 organizationComponents.add(organizationComponent);
12 }
13
14 @Override//重写
15 protected void remove(OrganizationComponent organizationComponent) {
16 organizationComponents.remove(organizationComponent);
17 }
18
19 @Override//重写
20 public String getName() {
21 return super.getName();
22 }
23
24 @Override//重写
25 public String getDes() {
26 return super.getDes();
27 }
28
29 @Override
30 protected void print() {
31 System.out.println("---------------" + getName() + "-------------------");
32 for (OrganizationComponent organizationComponent : organizationComponents) {
33 organizationComponent.print();
34 }
35 }
36}
1public class Depatment extends OrganizationComponent {
2
3 public Depatment(String name, String des) {
4 super(name, des);
5 }
6
7 @Override
8 protected void print() {
9 System.out.println(getName());
10 }
11
12 //add、remove不需要写了，因为它是叶子节点，不需要管理其他节点
13
14 @Override
15 public String getDes() {
16 return super.getDes();
17 }
18
19 @Override
20 public String getName() {
21 return super.getName();
22 }
23}
1public class Client {
2 public static void main(String[] args) {
3
4 //从大到小创建对象，学校
5 OrganizationComponent university = new University("清华大学", "顶级大学");
6
7 //学院
8 OrganizationComponent college1 = new College("计算机学院", "计算机学院");
9 OrganizationComponent college2 = new College("信息工程学院", "信息工程学院");
10
11 //专业
12 college1.add(new Depatment("软件工程", "软件工程"));
13 college1.add(new Depatment("网络工程", "网络工程"));
14 college2.add(new Depatment("通信工程", "通信工程"));
15 college2.add(new Depatment("信息工程", "信息工程"));
16
17 //将学院加入到学校
18 university.add(college1);
19 university.add(college2);
20
21 university.print();
22 college1.print();
23
24 }
25}
注意事项
简化客户端操作。
客户端只需要面对一致的对象而不用考虑整体部分或者叶子节点的问题。
具有较强的扩展性。当我们要更改组合对象时，我们只需要调整内部的层次关系，客户端不用做出任何改动。
方便创建出复杂的层次结构。客户端不用理会组合里面的组成细节，容易添加节点或者叶子从而创建出复杂的树形结构。
需要遍历组织机构，或者处理的对象具有树形结构时，非常适合使用组合模式。
要求较高的抽象性，如果节点和叶子有很多差异性的话，比如很多方法和属性都不一样，不适合使用组合模式。
JDK中的HashMap
