何须浅碧深红色,自是花中第一流。

——李清照《鹧鸪天》

## 设计模式-组合模式

1. 案例引出组合模式

编写程序展示一个学校院系结构(使用数据库中的表间关系很容易实现,注意这里是使用Java程序实现):需求是这样,要在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个专业,如下图:

image-20200623100442489

传统方式解决上述问题(类图如下):

image-20200623100926867

传统方案存在的问题:

  1. 将学院看做是学校的子类, 专业是学院的子类,这样实际上是站在组织大小来进行分层次的。
  2. 实际上我们的要求是 :在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个专业, 因此这种方案, 不能很好实现的管理的操作,比如对学院、专业的 添加,删除,遍历等。
  3. 解决方案:把学校、院、系都看做是组织结构,他们之间没有继承的关系,而是一个树形结构,可以更好的实现管理操作。这就要使用到设计模式中的组合模式。

2. 组合模式

2.1 组合模式基本介绍

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

2.2 组合模式类图

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

2b8bfd57-b4d1-4a75-bfb0-bcf1fba4014a

2.3 组合模式解决学校院系展示

类图结构

image-20200623103452887

代码实现
OrganizationComponent
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
public abstract class OrganizationComponent {

private String name; // 名字
private String des; // 说明

protected void add(OrganizationComponent organizationComponent) {
//默认实现
throw new UnsupportedOperationException();
}

protected void remove(OrganizationComponent organizationComponent) {
//默认实现
throw new UnsupportedOperationException();
}

//构造器
public OrganizationComponent(String name, String des) {
super();
this.name = name;
this.des = des;
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getDes() {
return des;
}

public void setDes(String des) {
this.des = des;
}

//方法print, 做成抽象的, 子类都需要实现
protected abstract void print();


}
University--Composite
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

//University 就是 Composite , 可以管理College
public class University extends OrganizationComponent {

List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();

// 构造器
public University(String name, String des) {
super(name, des);
}

// 重写add
@Override
protected void add(OrganizationComponent organizationComponent) {
organizationComponents.add(organizationComponent);
}

// 重写remove
@Override
protected void remove(OrganizationComponent organizationComponent) {
organizationComponents.remove(organizationComponent);
}

@Override
public String getName() {
return super.getName();
}

@Override
public String getDes() {
return super.getDes();
}

// print方法,就是输出University 包含的学院
@Override
protected void print() {
System.out.println("--------------" + getName() + "--------------");
//遍历 organizationComponents
for (OrganizationComponent organizationComponent : organizationComponents) {
organizationComponent.print();
}
}

}
College
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
public class College extends OrganizationComponent {

//List 中存放的Department
List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();

// 构造器
public College(String name, String des) {
super(name, des);
}

// 重写add
@Override
protected void add(OrganizationComponent organizationComponent) {
// 将来实际业务中,Colleage 的 add 和 University add 不一定完全一样
organizationComponents.add(organizationComponent);
}

// 重写remove
@Override
protected void remove(OrganizationComponent organizationComponent) {
organizationComponents.remove(organizationComponent);
}

@Override
public String getName() {
return super.getName();
}

@Override
public String getDes() {
return super.getDes();
}

// print方法,就是输出University 包含的学院
@Override
protected void print() {
System.out.println("--------------" + getName() + "--------------");
//遍历 organizationComponents
for (OrganizationComponent organizationComponent : organizationComponents) {
organizationComponent.print();
}
}


}
Department
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public class Department extends OrganizationComponent {

//没有集合
public Department(String name, String des) {
super(name, des);
}


//add , remove 就不用写了,因为他是叶子节点
@Override
public String getName() {
return super.getName();
}

@Override
public String getDes() {
return super.getDes();
}

@Override
protected void print() {
System.out.println(getName());
}

}
Client
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class Client {

public static void main(String[] args) {
//从大到小创建对象 学校
OrganizationComponent university = new University("南京工程学院", " 中国顶级大学 ");

//创建 学院
OrganizationComponent computerCollege = new College("计算机学院", " 计算机学院 ");
OrganizationComponent infoEngineercollege = new College("信息工程学院", " 信息工程学院 ");


//创建各个学院下面的系(专业)
computerCollege.add(new Department("软件工程", " 软件工程不错 "));
computerCollege.add(new Department("网络工程", " 网络工程不错 "));
computerCollege.add(new Department("计算机科学与技术", " 计算机科学与技术是老牌的专业 "));

infoEngineercollege.add(new Department("通信工程", " 通信工程不好学 "));
infoEngineercollege.add(new Department("信息工程", " 信息工程好学 "));

//将学院加入到 学校
university.add(computerCollege);
university.add(infoEngineercollege);

//university.print();
infoEngineercollege.print();
}

}

3 .组合模式在 JDK Map集合源码体现

Java 的集合类HashMap 就使用了组合模式

HashMap中的静态内部类Node相当于组合模式的中的Leaf 即叶子节点,叶子节点没有子节点。

Map接口相当于组合模式中的Component对象声明接口,用于访问和管理Component 子部件。

HashMap相当于组合模式中的Composite非叶子节点, 用于存储子部件,具体通过两个 方法体现出:

putAll

public void putAll(Map<? extends K, ? extends V> m)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
/**
* 将指定映射中的所有映射复制到此映射。这些映射将替换此映射对指定映射中当前键的任何映射。
*/
public void putAll(Map<? extends K, ? extends V> m) {
putMapEntries(m, true);
}

final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
int s = m.size();
if (s > 0) {
if (table == null) { // pre-size
float ft = ((float)s / loadFactor) + 1.0F;
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
if (t > threshold)
threshold = tableSizeFor(t);
}
else if (s > threshold)
resize();
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
putVal(hash(key), key, value, false, evict);
}
}
}
put

public V put(K key, V value) ;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
/**
*将此映射中的指定值与指定键关联。如果映射以前包含键的映射,旧值将被替换。
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}

/**
* 实现了Map及put相关方法
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
Node
1
2
3
4
5
6
7
8
9

static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;

// ...
}

put方法是将单个Node添加到HashMap中,而putAll方法是将一个HashMap放到另一个HashMap中,通过下面的关系映射:

  1. Node —-> 专业
  2. put —-> 院系添加专业
  3. putAll —-> 学校添加院系

因为put和putAll都是HashMap中的方法,所以HashMap相当于组合模式中的Composite非叶子节点。这样下来就可以理解了,面试的时候又可以吹一波了哈哈哈