设计模式（九）——组合模式

组合模式比较容易理解，想到组合模式就应该想到树状结构图，组合模式描述了如何将容器对象（非叶子节点）和叶子对象（叶子节点）进行递归组合，使得用户在使用时无需对他们进行区分，可以一致的对待容器对象和叶子对象，这就是组合模式的动机。
组合模式核心在于引入了一个抽象类，它既是叶子类父类又是容器类父类，客户端针对抽象构建进行编程，无需知道它到底代表容器还是代表叶子，可以对它做统一处理。
组合模式组成：抽象构件，叶子构件，容器构件。

//抽象构件类
public abstract class MyElement {

    public abstract void eat();
}
//叶子构件类
public class Apple extends MyElement {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("吃苹果");
    }

}
public class Banana extends MyElement {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("吃香蕉");
    }

}
public class Pear extends MyElement {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("吃梨子");
    }

}
//容器构件类
public class Plate extends MyElement {

    private ArrayList<MyElement> list = new ArrayList<MyElement>();
    public void add(MyElement element){
        list.add(element);
    }
    public void remove(MyElement element){
        list.remove(element);
    }
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        for(Object object:list){
            ((MyElement)object).eat();
        }
    }

}
//客户端调用
public class Client {

    public static void main(String[] args){
        MyElement obj1, obj2, obj3;
        Plate plate1 = null;
        obj1 = new Apple();
        obj2 = new Pear();
        obj3 = new Banana();
        plate1 = new Plate();

        plate1.add(obj1);
        plate1.add(obj2);
        plate1.add(obj3);

        plate1.eat();
    }
}

组合模式技术核心就是树的递归遍历，动机就是使得叶子节点和非叶子节点满足同一递归方程。
通过组合模式来模拟的杀毒过程：

import java.util.*;  

//抽象文件类：抽象构件  
abstract class AbstractFile {  
    public abstract void add(AbstractFile file);  
    public abstract void remove(AbstractFile file);  
    public abstract AbstractFile getChild(int i);  
    public abstract void killVirus();  
}  

//图像文件类：叶子构件  
class ImageFile extends AbstractFile {  
    private String name;  

    public ImageFile(String name) {  
        this.name = name;  
    }  

    public void add(AbstractFile file) {  
       System.out.println("对不起，不支持该方法！");  
    }  

    public void remove(AbstractFile file) {  
        System.out.println("对不起，不支持该方法！");  
    }  

    public AbstractFile getChild(int i) {  
        System.out.println("对不起，不支持该方法！");  
        return null;  
    }  

    public void killVirus() {  
        //模拟杀毒  
        System.out.println("----对图像文件'" + name + "'进行杀毒");  
    }  
}  

//文本文件类：叶子构件  
class TextFile extends AbstractFile {  
    private String name;  

    public TextFile(String name) {  
        this.name = name;  
    }  

    public void add(AbstractFile file) {  
       System.out.println("对不起，不支持该方法！");  
    }  

    public void remove(AbstractFile file) {  
        System.out.println("对不起，不支持该方法！");  
    }  

    public AbstractFile getChild(int i) {  
        System.out.println("对不起，不支持该方法！");  
        return null;  
    }  

    public void killVirus() {  
        //模拟杀毒  
        System.out.println("----对文本文件'" + name + "'进行杀毒");  
    }  
}  

//视频文件类：叶子构件  
class VideoFile extends AbstractFile {  
    private String name;  

    public VideoFile(String name) {  
        this.name = name;  
    }  

    public void add(AbstractFile file) {  
       System.out.println("对不起，不支持该方法！");  
    }  

    public void remove(AbstractFile file) {  
        System.out.println("对不起，不支持该方法！");  
    }  

    public AbstractFile getChild(int i) {  
        System.out.println("对不起，不支持该方法！");  
        return null;  
    }  

    public void killVirus() {  
        //模拟杀毒  
        System.out.println("----对视频文件'" + name + "'进行杀毒");  
    }  
}  

//文件夹类：容器构件  
class Folder extends AbstractFile {  
    //定义集合fileList，用于存储AbstractFile类型的成员  
    private ArrayList<AbstractFile> fileList=new ArrayList<AbstractFile>();  
    private String name;  

    public Folder(String name) {  
        this.name = name;  
    }  

    public void add(AbstractFile file) {  
       fileList.add(file);    
    }  

    public void remove(AbstractFile file) {  
        fileList.remove(file);  
    }  

    public AbstractFile getChild(int i) {  
        return (AbstractFile)fileList.get(i);  
    }  

    public void killVirus() {  
        System.out.println("****对文件夹'" + name + "'进行杀毒");  //模拟杀毒  

        //递归调用成员构件的killVirus()方法  
        for(Object obj : fileList) {  
            ((AbstractFile)obj).killVirus();  
        }  
    }  
}

组合模式优点：
（1）组合模式可以清楚的定义分层次的复杂对象，表示对象的全部或部分层次，使得增加新构件也更加容易，因为它让客户忽略了层次的差异，而它的结构又是动态的，提供了对象管理的灵活接口，因此组合模式可以方便的对层次结构进行控制。
（2）客户端不必因为加入了新的对象构件而改变原有代码。
组合模式缺点：
（1）有时候我们希望容器中的构件类型进行限制，容器中只有特定类型的对象，在这种情况下不能依赖类型系统来施加约束，因为他们都来自同一个抽象层。

透明组合模式和安全组合模式：
透明组合模式在抽象构件中声明所有用于管理成员对象的方法，包括一些叶子节点不应该具有的方法，比如增加节点，删除节点。这样的好处是确保所有的构件类都有相同的接口，客户端可以相同的对待所有的对象。但是这是不安全的，因为add（），remove（）等方法在叶子节点是没有意义的，编译期间不会出错，但是在运行期间可能出问题。
安全组合模式在抽象构件中不声明任何用于管理成员对象的方法，而是在Composite类中声明这些用于管理成员对象的方法。这种做法是安全的，因为根本不会向叶子节点提供这些管理成员对象的方法，对于叶子对象，客户端不可能调用到这些方法，安全组合模式缺点是不够透明，客户端不能完全针对抽象编程。