树形结构的处理-组合模式
树形结构在软件中随处可见，例如操作系统中的目录结构、应用软件中的菜单、办公系统中 的公司组织结构等等，如何运用面向对象的方式来处理这种树形结构是组合模式需要解决的 问题，组合模式通过一种巧妙的设计方案使得用户可以一致性地处理整个树形结构或者树形 结构的一部分，也可以一致性地处理树形结构中的叶子节点（不包含子节点的节点）和容器 节点（包含子节点的节点）。下面将学习这种用于处理树形结构的组合模式。
举个栗子：
Sunny软件公司欲开发一个杀毒(AntiVirus)软件，该软件既可以对某个文件夹(Folder)杀毒，也 可以对某个指定的文件(File)进行杀毒。该杀毒软件还可以根据各类文件的特点，为不同类型 的文件提供不同的杀毒方式，例如图像文件(ImageFile)和文本文件(TextFile)的杀毒方式就有所 差异。现需要提供该杀毒软件的整体框架设计方案。
文件树形目录结构：
GOF设计模式-对象结构型模式-组合模式组合模式概述： 我们可以看出，图中包含文件（灰色节点）和文件夹（白色节点）两类不同的元素，其 中在文件夹中可以包含文件，还可以继续包含子文件夹，但是在文件中不能再包含子文件或 者子文件夹。在此，我们可以称文件夹为容器(Container)，而不同类型的各种文件是其成员， 也称为叶子(Leaf)，一个文件夹也可以作为另一个更大的文件夹的成员。如果我们现在要对某 一个文件夹进行操作，如查找文件，那么需要对指定的文件夹进行遍历，如果存在子文件夹 则打开其子文件夹继续遍历，如果是文件则判断之后返回查找结果。
软件公司的开发人员通过分析，决定使用面向对象的方式来实现对文件和文件夹的操 作，定义了如下图像文件类ImageFile、文本文件类TextFile和文件夹类Folder： （反面教材）
//为了突出核心框架代码，我们对杀毒过程的实现进行了大量简化
import java.util.*;
//图像文件类
class ImageFile {
private String name;
public ImageFile(String name) {
this.name = name;
}
public void killVirus() {
//简化代码，模拟杀毒
System.out.println("----对图像文件'" + name + "'进行杀毒");
}
}
//文本文件类
class TextFile {
private String name;
public TextFile(String name) {
this.name = name;
}
public void killVirus() {
//简化代码，模拟杀毒
System.out.println("----对文本文件'" + name + "'进行杀毒");
}
}
//文件夹类
class Folder {
private String name;
//定义集合folderList，用于存储Folder类型的成员
private ArrayList<Folder> folderList = new ArrayList<Folder>();
//定义集合imageList，用于存储ImageFile类型的成员
private ArrayList<ImageFile> imageList = new ArrayList<ImageFile>();
//定义集合textList，用于存储TextFile类型的成员
private ArrayList<TextFile> textList = new ArrayList<TextFile>();
public Folder(String name) {
this.name = name;
}
//增加新的Folder类型的成员
public void addFolder(Folder f) {
folderList.add(f);
}
//增加新的ImageFile类型的成员
public void addImageFile(ImageFile image) {
imageList.add(image);
}
//增加新的TextFile类型的成员
public void addTextFile(TextFile text) {
textList.add(text);
}
//需提供三个不同的方法removeFolder()、removeImageFile()和removeTextFile()来删除成员
//需提供三个不同的方法getChildFolder(int i)、getChildImageFile(int i)和getChildTex
public void killVirus() {
System.out.println("****对文件夹'" + name + "'进行杀毒"); //模拟杀毒
//如果是Folder类型的成员，递归调用Folder的killVirus()方法
for (Object obj : folderList) {
((Folder) obj).killVirus();
}
//如果是ImageFile类型的成员，调用ImageFile的killVirus()方法
for (Object obj : imageList) {
((ImageFile) obj).killVirus();
}
//如果是TextFile类型的成员，调用TextFile的killVirus()方法
for (Object obj : textList) {
((TextFile) obj).killVirus();
}
}
}
//编写如下客户端测试代码进行测试：
class Client {
public static void main(String args[]) {
Folder folder1, folder2, folder3;
folder1 = new Folder("Sunny的资料");
folder2 = new Folder("图像文件");
folder3 = new Folder("文本文件");
ImageFile image1, image2;
image1 = new ImageFile("小龙女.jpg");
image2 = new ImageFile("张无忌.gif");
TextFile text1, text2;
text1 = new TextFile("九阴真经.txt");
text2 = new TextFile("葵花宝典.doc");
folder2.addImageFile(image1);
folder2.addImageFile(image2);
folder3.addTextFile(text1);
folder3.addTextFile(text2);
folder1.addFolder(folder2);
folder1.addFolder(folder3);
folder1.killVirus();
}
}
|
编译并运行程序，输出结果如下：
****对文件夹'Sunny的资料'进行杀毒 ****对文件夹'图像文件'进行杀毒 ----对图像文件'小龙女.jpg'进行杀毒 ----对图像文件'张无忌.gif'进行杀毒 ****对文件夹'文本文件'进行杀毒 ----对文本文件'九阴真经.txt'进行杀毒 ----对文本文件'葵花宝典.doc'进行杀毒
Sunny公司开发人员“成功”实现了杀毒软件的框架设计，但通过仔细分析，发现该设计方案存 在如下问题：
(1) 文件夹类Folder的设计和实现都非常复杂，需要定义多个集合存储不同类型的成员，而且 需要针对不同的成员提供增加、删除和获取等管理和访问成员的方法，存在大量的冗余代 码，系统维护较为困难；
(2) 由于系统没有提供抽象层，客户端代码必须有区别地对待充当容器的文件夹Folder和充当 叶子的ImageFile和TextFile，无法统一对它们进行处理；
(3) 系统的灵活性和可扩展性差，如果需要增加新的类型的叶子和容器都需要对原有代码进行 修改，例如如果需要在系统中增加一种新类型的视频文件VideoFile，则必须修改Folder类的源 代码，否则无法在文件夹中添加视频文件。
面对以上问题，Sunny软件公司的开发人员该如何来解决？这就需要用到本章将要介绍的组合 模式，组合模式为处理树形结构提供了一种较为完美的解决方案，它描述了如何将容器和叶 子进行递归组合，使得用户在使用时无须对它们进行区分，可以一致地对待容器和叶子。
组合模式概述：
对于树形结构，当容器对象（如文件夹）的某一个方法被调用时，将遍历整个树形结构，寻 找也包含这个方法的成员对象（可以是容器对象，也可以是叶子对象）并调用执行，牵一而 动百，其中使用了递归调用的机制来对整个结构进行处理。由于容器对象和叶子对象在功能 上的区别，在使用这些对象的代码中必须有区别地对待容器对象和叶子对象，而实际上大多 数情况下我们希望一致地处理它们，因为对于这些对象的区别对待将会使得程序非常复杂。 组合模式为解决此类问题而诞生，它可以让叶子对象和容器对象的使用具有一致性。
组合模式定义如下：
组合模式(Composite Pattern)：组合多个对象形成树形结构以表示具有“整体—部分”关系的层 次结构。组合模式对单个对象（即叶子对象）和组合对象（即容器对象）的使用具有一致 性，组合模式又可以称为“整体—部分”(Part-Whole)模式，它是一种对象结构型模式。
在组合模式中引入了抽象构件类Component，它是所有容器类和叶子类的公共父类，客户端针 对Component进行编程。
GOF设计模式-对象结构型模式-组合模式组合模式概述： 在组合模式结构图中包含如下几个角色：
● Component（抽象构件）：它可以是接口或抽象类，为叶子构件和容器构件对象声明接口， 在该角色中可以包含所有子类共有行为的声明和实现。在抽象构件中定义了访问及管理它的
子构件的方法，如增加子构件、删除子构件、获取子构件等。
● Leaf（叶子构件）：它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在 抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处 理。
● Composite（容器构件）：它在组合结构中表示容器节点对象，容器节点包含子节点，其子 节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象 构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子 节点的业务方法。
组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端 针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处 理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶 子，也可以包含容器，以此实现递归组合，形成一个树形结构。
如果不使用组合模式，客户端代码将过多地依赖于容器对象复杂的内部实现结构，容器对象 内部实现结构的变化将引起客户代码的频繁变化，带来了代码维护复杂、可扩展性差等弊 端。组合模式的引入将在一定程度上解决这些问题。
完整的解决方案：
为了让系统具有更好的灵活性和可扩展性，客户端可以一致地对待文件和文件夹，Sunny公司 开发人员使用组合模式来进行杀毒软件的框架设计，其基本结构如图：
GOF设计模式-对象结构型模式-组合模式组合模式概述： AbstractFile充当抽象构件类，Folder充当容器构件类，ImageFile、TextFile和 VideoFile充当叶子构件类。完整代码如下所示：
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();
}
}
}
//编写如下客户端测试代码：
class Client {
public static void main(String args[]) {
//针对抽象构件编程
AbstractFile file1, file2, file3, file4, file5, folder1, folder2, folder3, folder4;
folder1 = new Folder("Sunny的资料");
folder2 = new Folder("图像文件");
folder3 = new Folder("文本文件");
folder4 = new Folder("视频文件");
file1 = new ImageFile("小龙女.jpg");
file2 = new ImageFile("张无忌.gif");
file3 = new TextFile("九阴真经.txt");
file4 = new TextFile("葵花宝典.doc");
file5 = new VideoFile("笑傲江湖.rmvb");
folder2.add(file1);
folder2.add(file2);
folder3.add(file3);
folder3.add(file4);
folder4.add(file5);
folder1.add(folder2);
folder1.add(folder3);
folder1.add(folder4);
//从“Sunny的资料”节点开始进行杀毒操作
folder1.killVirus();
}
}
|
编译并运行程序，输出结果如下：
****对文件夹'Sunny的资料'进行杀毒
****对文件夹'图像文件'进行杀毒
----对图像文件'小龙女.jpg'进行杀毒
----对图像文件'张无忌.gif'进行杀毒
****对文件夹'文本文件'进行杀毒
----对文本文件'九阴真经.txt'进行杀毒
----对文本文件'葵花宝典.doc'进行杀毒
****对文件夹'视频文件'进行杀毒
----对视频文件'笑傲江湖.rmvb'进行杀毒
由于在本实例中使用了组合模式，在抽象构件类中声明了所有方法，包括用于管理和访问子 构件的方法，如add()方法和remove()方法等，因此在ImageFile等叶子构件类中实现这些方法时 必须进行相应的异常处理或错误提示。在容器构件类Folder的killVirus()方法中将递归调用其成 员对象的killVirus()方法，从而实现对整个树形结构的遍历。
如果需要更换操作节点，例如只需对文件夹“文本文件”进行杀毒，客户端代码只需修改一行即 可，将
代码：
folder1.killVirus();
改为：
folder3.killVirus();
输出结果如下：
****对文件夹'文本文件'进行杀毒 ----对文本文件'九阴真经.txt'进行杀毒 ----对文本文件'葵花宝典.doc'进行杀毒
在具体实现时，我们可以创建图形化界面让用户选择所需操作的根节点，无须修改源代码， 符合“开闭原则”，客户端无须关心节点的层次结构，可以对所选节点进行统一处理，提高系统 的灵活性。
组合模式总结
组合模式使用面向对象的思想来实现树形结构的构建与处理，描述了如何将容器对象和叶子 对象进行递归组合，实现简单，灵活性好。由于在软件开发中存在大量的树形结构，因此组 合模式是一种使用频率较高的结构型设计模式。
组合模式的主要优点如下：
(1) 组合模式可以清楚地定义分层次的复杂对象，表示对象的全部或部分层次，它让客户端忽 略了层次的差异，方便对整个层次结构进行控制。
(2) 客户端可以一致地使用一个组合结构或其中单个对象，不必关心处理的是单个对象还是整 个组合结构，简化了客户端代码。
(3) 在组合模式中增加新的容器构件和叶子构件都很方便，无须对现有类库进行任何修改，符 合“开闭原则”。
(4) 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和容器对 象的递归组合，可以形成复杂的树形结构，但对树形结构的控制却非常简单。
组合模式的主要缺点如下：
在增加新构件时很难对容器中的构件类型进行限制。有时候我们希望一个容器中只能有某些 特定类型的对象，例如在某个文件夹中只能包含文本文件，使用组合模式时，不能依赖类型 系统来施加这些约束，因为它们都来自于相同的抽象层，在这种情况下，必须通过在运行时 进行类型检查来实现，这个实现过程较为复杂。
在以下情况下可以考虑使用组合模式：
(1) 在具有整体和部分的层次结构中，希望通过一种方式忽略整体与部分的差异，客户端可以 一致地对待它们。
(2) 在一个使用面向对象语言开发的系统中需要处理一个树形结构。
(3) 在一个系统中能够分离出叶子对象和容器对象，而且它们的类型不固定，需要增加一些新 的类型。
