设计模式系列往期精彩文章

无场景不设计，下面有这样一个场景：
编写程序展示一个学校院系结构：需求是这样，要在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系。如图：

如果是你接到这样一个需求你会怎么去做呢？（思考一分钟…..）

传统解决方案（拓展图）：

如图所示：按照常规思想我们会把它做成一个继承关系。
思考：它们彼此的关系真的是继承关系吗?

其实更合适的一种关系是学校包含学院，学院包含系

更准确的的描述它们之间的关系：是组合关系

传统解决方案总结分析

将学院看做是学校的子类，系是学院的子类，这样实际上是站在组织大小来进行分层次的
实际上我们的要求是：在一个页面中展示出学校的院系组成，一个学校有多个学院，一个学院有多个系，因此这种方案，不能很好实现的管理的操作，比如对学院、系的添加，删除，遍历等

综上所述，我们大概也清楚了按照传统解决方案去设计展示一个学校院系的结构是欠佳的。那我们如何解决呢？

进阶思路

把学校、院、系都看做是组织结构，他们之间没有继承的关系，而是一个树形结构，可以更好的实现管理操作。=> 组合模式

好了到这里，我么抛砖引玉，提出了组合模式的概念，那么什么是组合模式呢？接下来为大家详细介绍。

组合模式

基本介绍：

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

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

这种设计模式属于结构性模式

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

好了相关的组合模式概念也就讲完了。是不是听的晕晕乎乎的，任何一种模式用语言来描述都是及其复杂的，但是实现起来就很容易理解。下面我给大家简单地绘画一个组合模式的原理类图:

对原理结构图的说明-即(组合模式的角色及职责)

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

Leaf：在组合模式中表示叶子节点，叶子节点没有子节点 3.Composite：非叶子节点，用于存储子部件，在Component接口中实现子部件相关操作，比如增加，删除

讲了这么多的理论知识，究竟组合模式可以解决哪些问题呢？

当我们的要处理的对象可以生成一颗树形结构，而我们要对树上的节点和叶子进行操作时，它能够提供一致的方式，而不用考虑它是节点还是叶子
对应的示意图

到这里，组合模式的基础概念以及相关组成部分已经讲完了。接下来直接撸代码。实操起来。

应用实例

关于学校院系的设计原理类图：

注意：

这里Department 聚合 College 聚合 University，是将OrganizationComponent作为属性放在Composite(也就是College、University)

根据上述类图来编写代码;

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

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

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

	// 构造器
	public University(String name, String des) {
		super(name, des);
		// TODO Auto-generated constructor stub
	}

	// 重写add
	@Override
	protected void add(OrganizationComponent organizationComponent) {
		// TODO Auto-generated method stub
		organizationComponents.add(organizationComponent);
	}

	// 重写remove
	@Override
	protected void remove(OrganizationComponent organizationComponent) {
		// TODO Auto-generated method stub
		organizationComponents.remove(organizationComponent);
	}

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return super.getName();
	}

	@Override
	public String getDes() {
		// TODO Auto-generated method stub
		return super.getDes();
	}

	// print方法，就是输出University 包含的学院
	@Override
	protected void print() {
		// TODO Auto-generated method stub
		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);
		// TODO Auto-generated constructor stub
	}

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

	// 重写remove
	@Override
	protected void remove(OrganizationComponent organizationComponent) {
		// TODO Auto-generated method stub
		organizationComponents.remove(organizationComponent);
	}

	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return super.getName();
	}

	@Override
	public String getDes() {
		// TODO Auto-generated method stub
		return super.getDes();
	}

	// print方法，就是输出University 包含的学院
	@Override
	protected void print() {
		// TODO Auto-generated method stub
		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);
		// TODO Auto-generated constructor stub
	}

	
	//add , remove 就不用写了，因为他是叶子节点
	
	@Override
	public String getName() {
		// TODO Auto-generated method stub
		return super.getName();
	}
	
	@Override
	public String getDes() {
		// TODO Auto-generated method stub
		return super.getDes();
	}
	
	@Override
	protected void print() {
		// TODO Auto-generated method stub
		System.out.println(getName());
	}

}

Client

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		
		//从大到小创建对象 学校
		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();
	}

}

终于将组合模式的基本概念以及应用案例讲解完了。那么还是老样子，究竟组合模式在JDK中哪里有应用呢？让我们一看究竟吧。

组合模式在JDK集合的源码分析:

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

源码分析

   Map<Integer,String> hashMap=new HashMap<Integer,String>();
            hashMap.put(0, "名著");//直接存放叶子节点(Node)

            Map<Integer,String> map=new HashMap<Integer,String>();
            map.put(1, "西游记");
            map.put(2, "红楼梦"); //..
            hashMap.putAll(map);
            System.out.println(hashMap);

首先我们先查看Map的源码得知：Map是一个接口，(其实就相当于一个Component，因为之前有说过Component可以是接口或者抽象类),为什么这么说呢？
因为从源码我们可以看出这个接口有很多方法，比如：put、putAll。

如图：

接下来我们看一下Map下面的子类有哪些呢？我们大致看一眼

如图所示它的子类有一个AbstractMap在AbstractMap中默认实现了put方法(抛出了一个不支持的异常)，说明了这个方法还需要下面的子类进行实现。

其实AbstractMap也相当于Component，不同之处就在于，AbstractMap是一个抽象类，Map是一个接口，它多做了一层，首先声明一个接口(Map)，抽象类(AbstractMap)去实现这个接口；这里的Component(Abstract)做了两层，我们上述的Component只做了一层。

接下来我们看Abstract下有没有子类呢？我们看到了熟悉的HashMap

我们看到（下图）HashMap继承了AbstractMap并且实现了Map，这里HashMap就相当于上述应用案例的College和University（也就是Composite）；

为什么这么说呢？因为HashMap将put方法进行了具体的实现（调用了putVal()这个方法）;putAll()方法调用了putMapEntries()。

讲到这里聪明的小伙伴就会发现ComponentAbstractMap)、Composite(HashMap)都有了,但是为什么没有Leaf(叶子节点)呢？

其实叶子节点是有的，你仔细查看不难发现HashMap有一个静态内部类Node,这个Node就类似我们之前讲得叶子节点，因为它的下面并没有put putAll方法，只有getKey()、getValue()…

如图：

追put()方法时不难发现;put()里面有个putVal(),putVal()里面得到一个key和value，把key和value做了一个Node放到了我们这个HashMap里面去

源码如图：

以上就是HashMap的源码分析
类图：

源码分析总结说明

Map 就是一个抽象的构建 (类似我们的Component)
HashMap是一个中间的构建(Composite), 实现/继承了相关方法 put, putAll 因为HashMap也继承了Abstract 这里不去细讲
Node 是 HashMap的静态内部类，类似Leaf叶子节点, 这里就没有put, ptall static class Node<K,V> implements Map.Entry<K,V>