何须浅碧深红色,自是花中第一流。
——李清照《鹧鸪天》
## 设计模式-组合模式
1. 案例引出组合模式
编写程序展示一个学校院系结构(使用数据库中的表间关系很容易实现,注意这里是使用Java程序实现):需求是这样,要在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个专业,
如下图:
传统方式解决上述问题(类图如下):
传统方案存在的问题:
- 将学院看做是学校的子类, 专业是学院的子类,这样实际上是站在组织大小来进行分层次的。
- 实际上我们的要求是 :在一个页面中展示出学校的院系组成,一个学校有多个学院,一个学院有多个专业, 因此这种方案, 不能很好实现的管理的操作,比如对学院、专业的 添加,删除,遍历等。
- 解决方案:把学校、院、系都看做是组织结构,他们之间没有继承的关系,而是一个树形结构,可以更好的实现管理操作。这就要使用到设计模式中的组合模式。
2. 组合模式
2.1 组合模式基本介绍
组合模式(Composite Pattern),又叫部分整体模式
,它创建了对象组的树形结构,将对象组合成树状结构以表示“ 整体- 部分”的层次关系
。
- 组合模式依据树形结构来组合对象,用来表示部分以及整体层次。
- 这种类型的设计模式属于结构型模式。
组合模式使得 用户对单个对象和组合对象的访问具有一致性,即:组合能让客户以一致的方式处理个别对象以及组合对象。
2.2 组合模式类图
- Component :这是组合中对象声明接口,在适当情况下,实现所有类共有的接口默认行为,用于访问和管理Component 子部件, Component 可以是抽象类或者接口。
- Leaf : 在组合中表示叶子节点,叶子节点没有子节点。
- Composite :非叶子节点, 用于存储子部件, 在 Component 接口中实现 子部件的相关操作,比如增加(add),删除。
2.3 组合模式解决学校院系展示
类图结构
代码实现
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; } 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
|
public class University extends OrganizationComponent {
List<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
public University(String name, String des) { super(name, des); }
@Override protected void add(OrganizationComponent organizationComponent) { organizationComponents.add(organizationComponent); }
@Override protected void remove(OrganizationComponent organizationComponent) { organizationComponents.remove(organizationComponent); }
@Override public String getName() { return super.getName(); }
@Override public String getDes() { return super.getDes(); }
@Override protected void print() { System.out.println("--------------" + getName() + "--------------"); 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<OrganizationComponent> organizationComponents = new ArrayList<OrganizationComponent>();
public College(String name, String des) { super(name, des); }
@Override protected void add(OrganizationComponent organizationComponent) { organizationComponents.add(organizationComponent); }
@Override protected void remove(OrganizationComponent organizationComponent) { organizationComponents.remove(organizationComponent); }
@Override public String getName() { return super.getName(); }
@Override public String getDes() { return super.getDes(); }
@Override protected void print() { System.out.println("--------------" + getName() + "--------------"); 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); }
@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); 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) { 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); }
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) treeifyBin(tab, hash); break; } if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } if (e != null) { 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
中,通过下面的关系映射:
- Node —-> 专业
- put —-> 院系添加专业
putAll
—-> 学校添加院系
因为put和putAll
都是HashMap
中的方法,所以HashMap
相当于组合模式中的Composite
非叶子节点。这样下来就可以理解了,面试的时候又可以吹一波了哈哈哈
☆