JavaSE-设计模式/11.设计模式-组合模式【it❤ld】

JavaSE-设计模式/11.设计模式-组合模式

发表于 2020-12-19 | 更新于 2020-12-19

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

——李清照《鹧鸪天》

## 设计模式-组合模式

1. 案例引出组合模式

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

传统方式解决上述问题（类图如下）：

传统方案存在的问题：

将学院看做是学校的子类，专业是学院的子类，这样实际上是站在组织大小来进行分层次的。

实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个专业，因此这种方案，不能很好实现的管理的操作，比如对学院、专业的添加，删除，遍历等。

解决方案：把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作。这就要使用到设计模式中的组合模式。

2. 组合模式

2.1 组合模式基本介绍

组合模式（Composite Pattern），又叫部分整体模式，它创建了对象组的树形结构，将对象组合成树状结构以表示“ 整体- 部分”的层次关系。

组合模式依据树形结构来组合对象，用来表示部分以及整体层次。

这种类型的设计模式属于结构型模式。

组合模式使得用户对单个对象和组合对象的访问具有一致性，即：组合能让客户以一致的方式处理个别对象以及组合对象。

2.2 组合模式类图

Component :这是组合中对象声明接口，在适当情况下，实现所有类共有的接口默认行为,用于访问和管理Component 子部件, Component 可以是抽象类或者接口。

Leaf : 在组合中表示叶子节点，叶子节点没有子节点。

Composite :非叶子节点，用于存储子部件，在 Component 接口中实现子部件的相关操作，比如增加(add),删除。

2b8bfd57-b4d1-4a75-bfb0-bcf1fba4014a

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

类图结构

代码实现

`OrganizationComponent`

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`


//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`

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`


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

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)

/**
 * 将指定映射中的所有映射复制到此映射。这些映射将替换此映射对指定映射中当前键的任何映射。
 */
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) ;

/**
  *将此映射中的指定值与指定键关联。如果映射以前包含键的映射，旧值将被替换。
  */
 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


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非叶子节点。这样下来就可以理解了，面试的时候又可以吹一波了哈哈哈

☆

本文作者: DuanChaojie

本文链接: http://www.itbuild.cn/2020/12/19/JavaSE-%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F/11.%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F-%E7%BB%84%E5%90%88%E6%A8%A1%E5%BC%8F/