设计模式笔记--组合模式
常用设计模式有23中，分为：
创建型模式（主要用于创建对象）
1、单例模式 2、工厂方法模式 3、抽象工厂模式 4、建造者模式 5、原型模式行为型模式 （主要用于描述对象或类是怎样交互和怎样分配职责）
1、模板方法模式 2、中介者模式 3、命令模式 4、责任链模式 5、策略模式 6、迭代器模式
7、观察者模式 8、备忘录模式 9、访问者模式 10、状态模式 11、解释器模式结构型模式(主要用于处理类或对象的组合)
1、代理模式 2、装饰模式 3、适配器模式 4、组合模式 5、外观模式（门面模式） 6、享元模式 7、桥梁模式
组合模式
组合模式(Composite Pattern)也叫合成模式，有时又叫做部分-整体模式（Part-Whole），主要是用来描述部分与整体的关系，其定义如下：
将对象组合成树形结构以表示“部分-整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致性
组合模式的几个角色
● Component抽象构件角色
定义参加组合对象的共有方法和属性，可以定义一些默认的行为或属性，比如我们例子中的getInfo就封装到了抽象类中。
● Leaf叶子构件
叶子对象，其下再也没有其他的分支，也就是遍历的最小单位。
● Composite树枝构件
树枝对象，它的作用是组合树枝节点和叶子节点形成一个树形结构。
组合模式的通用源代码
首先看抽象构件，它是组合模式的精髓，如代码清单21-18所示。
代码清单21-18 抽象构件
public abstract class Component {
//个体和整体都具有的共享
public void doSomething(){
//编写业务逻辑
}
} 组合模式的重点就在树枝构件，其通用代码如代码清单21-19所示。
代码清单21-19 树枝构件
public class Composite extends Component {
//构件容器
private ArrayList componentArrayList = new ArrayList();
//增加一个叶子构件或树枝构件
public void add(Component component){
this.componentArrayList.add(component);
}
//删除一个叶子构件或树枝构件
public void remove(Component component){
this.componentArrayList.remove(component);
}
//获得分支下的所有叶子构件和树枝构件
public ArrayList getChildren(){
return this.componentArrayList;
}
} 树叶节点是没有子下级对象的对象，定义参加组合的原始对象行为，其通用源代码如代码清单21-20所示。
public class Leaf extends Component {
/*
* 可以覆写父类方法
* public void doSomething(){
*
* }
*/
}场景类负责树状结构的建立，并可以通过递归方式遍历整个树，如代码清单21-21所示。
代码清单21-21 场景类
public class Client {
public static void main(String[] args) {
//创建一个根节点
Composite root = new Composite();
root.doSomething();
//创建一个树枝构件
Composite branch = new Composite();
//创建一个叶子节点
Leaf leaf = new Leaf();
//建立整体
root.add(branch);
branch.add(leaf);
}
//通过递归遍历树
public static void display(Composite root){
for(Component c:root.getChildren()){
if(c instanceof Leaf){ //叶子节点
c.doSomething();
}else{ //树枝节点
display((Composite)c);
}
}
}
} 各位可能已经看出一些问题了，组合模式是对依赖倒转原则的破坏，但是它还有其他类型的变形，面向对象就是这么多的形态和变化，请读者继续阅读下去，就会找到解决方案。
组合模式的优点
● 高层模块调用简单
● 节点自由增加
组合模式的缺点
直接使用了实现类！这在面向接口编程上是很不恰当的，与依赖倒置原则冲突，在使用的时候要考虑清楚，它限制了你接口的影响范围。
使用场景
● 维护和展示部分-整体关系的场景，如树形菜单、文件和文件夹管理。
注意事项
只要是树形结构，就要考虑使用组合模式，这个一定要记住，只要是要体现局部和整体的关系的时候，而且这种关系还可能比较深，考虑一下组合模式吧。
实例 遍历公司组织结构
代码清单21-14 抽象公司职员类
public abstract class Corp {
//公司每个人都有名称
private String name = "";
//公司每个人都职位
private String position = "";
//公司每个人都有薪水
private int salary =0;
public Corp(String _name,String _position,int _salary){
this.name = _name;
this.position = _position;
this.salary = _salary;
}
//获得员工信息
public String getInfo(){
String info = "";
info = "姓名：" + this.name;
info = info + "\t职位："+ this.position;
info = info + "\t薪水：" + this.salary;
return info;
}
} 抽象类嘛，就应该抽象出一些共性的东西出来，然后看两个具体的实现类，树叶节点如代码清单21-15所示。
代码清单21-15 树叶节点
public class Leaf extends Corp {
//就写一个构造函数，这个是必需的
public Leaf(String _name,String _position,int _salary){
super(_name,_position,_salary);
}
} 这个精简得比较多，几行代码就完成了，确实就应该这样，下面是小头目的实现类，如代码清单21-16所示。
代码清单21-16 树枝节点
public class Branch extends Corp {
//领导下边有哪些下级领导和小兵
ArrayList subordinateList = new ArrayList();
//构造函数是必需的
public Branch(String _name,String _position,int _salary){
super(_name,_position,_salary);
}
//增加一个下属，可能是小头目，也可能是个小兵
public void addSubordinate(Corp corp) {
this.subordinateList.add(corp);
}
//我有哪些下属
public ArrayList getSubordinate() {
return this.subordinateList;
}
} 场景类中构建树形结构，并进行遍历。组装没有变化，遍历组织机构数稍有变化，如代码清单21-17所示。
代码清单21-17 稍稍修改的场景类
public class Client {
//遍历整棵树,只要给我根节点，我就能遍历出所有的节点
public static String getTreeInfo(Branch root){
ArrayList subordinateList = root.getSubordinate();
String info = "";
for(Corp s :subordinateList){
if(s instanceof Leaf){ //是员工就直接获得信息
info = info + s.getInfo()+"\n";
}else{ //是个小头目
info = info+s.getInfo()+"\n"+ getTreeInfo((Branch)s);
}
}
return info;
}
} 组合模式的扩展
1）真实的组合模式
就是你在实际项目中使用的组合模式，而不是仅仅依照书本上学习到的模式，它是“实践出真知”
它依靠了关系数据库的非对象存储性能，非常方便地保存了一个树形结构。
2）透明的组合模式
组合模式有两种不同的实现：透明模式和安全模式，
上面讲的就是安全模式
透明模式是把用来组合使用的方法放到抽象类中，比如add()、remove()以及getChildren等方法（顺便说一下，getChildren一般返回的结果为Iterable的实现类，很多，大家可以看JDK的帮助），不管叶子对象还是树枝对象都有相同的结构，通过判断是getChildren的返回值确认是叶子节点还是树枝节点，如果处理不当，这个会在运行期出现问题，不是很建议的方式
由于透明模式的使用者还是比较多，我们也把它的通用源代码共享出来，首先看抽象构件，如代码清单21-22所示。
代码清单21-22 抽象构件
public abstract class Component {
//个体和整体都具有的共享
public void doSomething(){
//编写业务逻辑
}
//增加一个叶子构件或树枝构件
public abstract void add(Component component);
//删除一个叶子构件或树枝构件
public abstract void remove(Component component);
//获得分支下的所有叶子构件和树枝构件
public abstract ArrayList getChildren();
}
抽象构件定义了树枝节点和树叶节点都必须具有的方法和属性，这样树枝节点的实现就不需要任何变化，
public class Composite extends Component {
//构件容器
private ArrayList componentArrayList = new ArrayList();
//增加一个叶子构件或树枝构件
public void add(Component component){
this.componentArrayList.add(component);
}
//删除一个叶子构件或树枝构件
public void remove(Component component){
this.componentArrayList.remove(component);
}
//获得分支下的所有叶子构件和树枝构件
public ArrayList getChildren(){
return this.componentArrayList;
}
} 树叶节点继承了Component抽象类，不想让它改变有点难，它必须实现三个抽象方法， 怎么办？好办，给个空方法，如代码清单 21-23所示。
代码清单21-23 树叶节点
public class Leaf extends Component {
@Deprecated
public void add(Component component) throws UnsupportedOperationException{
//空实现,直接抛弃一个"不支持请求"异常
throw new UnsupportedOperationException();
}
@Deprecated
public void remove(Component component)throws UnsupportedOperationException{
//空实现
throw new UnsupportedOperationException();
}
@Deprecated
public ArrayList getChildren()throws UnsupportedOperationException{
//空实现
throw new UnsupportedOperationException();
}
} 为什么要加个Deprecated注解呢？就是在编译器期告诉调用者，你可以调我这个方法，但是可能出现错误哦，我已经告诉你“该方法已经失效”了，你还使用那在运行期也会抛出
UnsupportedOperationException异常。
在透明模式下，遍历整个树形结构是比较容易的，不用进行强制类型转换，如代码清单21-24所示。
代码清单21-24 树结构遍历
public class Client {
//通过递归遍历树
public static void display(Component root){
for(Component c:root.getChildren()){
if(c instanceof Leaf){ //叶子节点
c.doSomething();
}else{ //树枝节点
display(c);
}
}
}
} 仅仅在遍历时不再进行牵制的类型转化了，其他的组装则没有任何变化。透明模式的好处就是它基本遵循了依赖倒转原则，方便系统进行扩展。
3）组合模式的遍历
看类图中，在Corp类中增加了两个方法，setParent是设置父节点是谁，getParent是查找父节点是谁，
看懂程序了吗？甭管是树枝节点还是树叶节点，在每个节点都增加了一个属性：父节点对象，这样在树枝节点增加子节点或叶子节点是设置父节点，然后你看整棵树除了根节点外每个节点都有一个父节点
有了这个parent属性，什么后序遍历（从下往上找）、中序遍历（从中间某个环节往上或往下遍历）都解决了，这个就不多说了。