java设计模式-组合模式

组合模式

组合模式（Composite pattern）是一种结构型设计模式， 你可以使用它将对象组合成树状结构， 并且能像使用独立对象一样使用它们。

在使用组合模式中需要注意一点也是组合模式最关键的地方：叶子对象和组合对象实现相同的接口。这就是组合模式能够将叶子节点和对象节点进行一致处理的原因。

组合模式-允许你将对象组成树形结构来表现“整体/部分”的层次结构。组合能让客户以一致的方式处理个别对象和对象组合

设计背景

计算机的文件系统，文件系统由文件和目录组成，目录下面也可以包含文件或者目录，计算机的文件系统是用递归结构来进行组织的，对于这样的数据结构是非常适用使用组合模式的。

在文件系统中，可能存在很多种格式的文件，如果图片，文本文件、视频文件等等，这些不同的格式文件的浏览方式都不同，同时对文件夹的浏览就是对文件夹中文件的浏览，但是对于客户而言都是浏览文件，两者之间不存在什么差别，现在只用组合模式来模拟浏览文件

其他例图：

模式结构和定义

组合模式主要包含如下几个角色：

• Component ：组合中的对象声明接口，在适当的情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件
• Leaf：叶子对象。叶子结点没有子结点。
• Composite：容器对象，定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关操作，如增加(add)和删除(remove)等。

从模式结构中我们看出了叶子节点和容器对象都实现Component接口，这也是能够将叶子对象和容器对象一致对待的关键所在。

应用实例

/**
* @author shengyong.huang
* @date 2020-06-20
*/
public abstract class File {
    String name;
    public File(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public abstract void display();
}
/**
* @author shengyong.huang
* @date 2020-06-20
*/
public class Folder extends File {
    private List<File> files;
    public Folder(String name) {
        super(name);
        files = new ArrayList<File>();
    }
    /**
     * 浏览文件夹中的文件
     */
    @Override
    public void display() {
        for (File file : files) {
            file.display();
        }
    }
    /**
     * @param file
     * @return void
     * @desc 向文件夹中添加文件
     */
    public void add(File file) {
        files.add(file);
    }
    /**
     * @param file
     * @return void
     * @desc 从文件夹中删除文件
     */
    public void remove(File file) {
        files.remove(file);
    }
}
/**
* @author shengyong.huang
* @date 2020-06-20
*/
public class ImagerFile extends File {
    public ImagerFile(String name) {
        super(name);
    }
    @Override
    public void display() {
        System.out.println("这是图像文件，文件名：" + super.getName());
    }
}
/**
* @author shengyong.huang
* @date 2020-06-20
*/
public class TextFile extends File {
    public TextFile(String name) {
        super(name);
    }
    @Override
    public void display() {
        System.out.println("这是文本文件，文件名：" + super.getName());
    }
}
/**
* @author shengyong.huang
* @date 2020-06-20
*/
public class VideoFile extends File{
    public VideoFile(String name) {
        super(name);
    }
    @Override
    public void display() {
        System.out.println("这是影像文件，文件名：" + super.getName());
    }
}
/**
* 测试方法
*
* @author shengyong.huang
* @date 2020-06-20
*/
public class TestMain {
    public static void main(String[] args) {
        /*
         * 我们先建立一个这样的文件系统
         * 总文件
         *
         * a.txt   b.jpg    c文件夹
         *                  c_1.text  c_1.rmvb    c_1.jpg
         *
         */
        //总文件夹
        Folder zwjj = new Folder("总文件夹");
        //向总文件夹中放入三个文件：1.txt、2.jpg、1文件夹
        TextFile aText = new TextFile("a.txt");
        ImagerFile bImager = new ImagerFile("b.jpg");
        Folder cFolder = new Folder("C文件夹");
        zwjj.add(aText);
        zwjj.add(bImager);
        zwjj.add(cFolder);
        //向C文件夹中添加文件：c_1.txt、c_1.rmvb、c_1.jpg
        TextFile cText = new TextFile("c_1.txt");
        ImagerFile cImage = new ImagerFile("c_1.jpg");
        VideoFile cVideo = new VideoFile("c_1.rmvb");
        cFolder.add(cText);
        cFolder.add(cImage);
        cFolder.add(cVideo);
        //遍历C文件夹
        cFolder.display();
        //将c_1.txt删除
        cFolder.remove(cText);
        System.out.println("-----------------------");
        cFolder.display();
    }
}

优点和不足

优点

• 可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，使得增加新构件也更容易。

• 客户端调用简单，客户端可以一致的使用组合结构或其中单个对象。

• 定义了包含叶子对象和容器对象的类层次结构，叶子对象可以被组合成更复杂的容器对象，而这个容器对象又可以被组合，这样不断递归下去，可以形成复杂的树形结构。

• 更容易在组合体内加入对象构件，客户端不必因为加入了新的对象构件而更改原有代码。

缺点

• 使设计变得更加抽象，对象的业务规则如果很复杂，则实现组合模式具有很大挑战性，而且不是所有的方法都与叶子对象子类都有关联。

使用场景

• 需要表示一个对象整体或部分层次，在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，可以一致地对待它们。
• 让客户能够忽略不同对象层次的变化，客户端可以针对抽象构件编程，无须关心对象层次结构的细节。

补充总结

组合模式用于将多个对象组合成树形结构以表示“整体-部分”的结构层次。组合模式对单个对象（叶子对象）和组合对象（容器对象）的使用具有一致性。

组合对象的关键在于它定义了一个抽象构建类，它既可表示叶子对象，也可表示容器对象，客户仅仅需要针对这个抽象构建进行编程，无须知道他是叶子对象还是容器对象，都是一致对待。

组合模式虽然能够非常好地处理层次结构，也使得客户端程序变得简单，但是它也使得设计变得更加抽象，而且也很难对容器中的构件类型进行限制，这会导致在增加新的构件时会产生一些问题。

参考：
https://www.cnblogs.com/chenssy/p/3299719.html