【Java设计模式】：结构型模式—组合模式

1. 组合模式的定义

组合模式，就是在一个对象中包含其他对象，这些被包含的对象可能是终点对象（不再包含别的对象），也有可能是非终点对象（其内部还包含其他对象，或叫组对象），我们将对象称为节点，即一个根节点包含许多子节点，这些子节点有的不再包含子节点，而有的仍然包含子节点，以此类推。很明显，这是树形结构，终结点叫叶子节点，非终节点（组节点）叫树枝节点，第一个节点叫根节点。同时也类似于文件目录的结构形式：文件可称之为终节点，目录可称之为非终节点（组节点）。

2. 目录结构的普通实现方式

因为组合模式和树形图有类似。一说到树形结构，我们很容易想到目录结构正是这种典型的树形结构数据。目录下面会包含子目录和文件。然后子目录下面又包含着目录和文件。这是一个递归的过程。

下面我们通过普通的方式来实现一下目录结构。

具体代码

目录节点：Noder：

import java.util.ArrayList;
import java.util.List;
/**
 * 目录节点
 * 包含：
 *         1、目录名
 *         2、下级文件列表
 *         3、下级目录列表
 *         4、新增文件方法
 *         5、新增目录方法
 *         6、显示下级内容方法
 */
public class Noder {
    String nodeName;//目录名
    //通过构造器为目录命名
    public Noder(String nodeName){
        this.nodeName = nodeName;
    }
    List<Noder> nodeList = new ArrayList<Noder>();//目录的子目录列表
    List<Filer> fileList = new ArrayList<Filer>();//目录下的文件列表
    //新增下级目录
    public void addNoder(Noder noder){
        nodeList.add(noder);
    }
    //新增文件
    public void addFiler(Filer filer){
        fileList.add(filer);
    }
    //显示下级目录及文件
    public void display(){
        for(Noder noder:nodeList){
            System.out.println(noder.nodeName);
            noder.display();//递归显示目录列表
        }
        for(Filer filer:fileList){
            filer.display();
        }
    }
}

文件节点：Filer

/**
 * 文件节点
 * 文件节点是终节点，无下级节点
 * 包含：
 *         1、文件名
 *         2、文件显示方法
 */
public class Filer {
    String fileName;//文件名
    public Filer(String fileName){
        this.fileName = fileName;
    }
    //文件显示方法
    public void display(){
        System.out.println(fileName);
    }
}

测试类：Clienter

import java.io.File;

public class Clienter {
    public static void createTree(Noder node){
        File file = new File(node.nodeName);
        File[] f = file.listFiles();
        for(File fi : f){
            if(fi.isFile()){
                Filer filer = new Filer(fi.getAbsolutePath());
                node.addFiler(filer);
            }
            if(fi.isDirectory()){
                Noder noder = new Noder(fi.getAbsolutePath());
                node.addNoder(noder);
                createTree(noder);//使用递归生成树结构
            }
        }
    }
    public static void main(String[] args) {
        Noder noder = new Noder("E://ceshi");
        createTree(noder);//创建目录树形结构
        noder.display();//显示目录及文件
    }
}

运行结果：

E:\ceshi\目录1
E:\ceshi\目录1\目录3
E:\ceshi\目录1\文件2.txt
E:\ceshi\目录2
E:\ceshi\目录2\文件3.txt
E:\ceshi\文件1.txt

3. 用组合模式实现目录结构

从上面的代码中可以看出，我们分别定义了文件节点对象与目录节点对象，这是因为文件与目录之间的操作不同，文件没有下级节点，而目录可以有下级节点，但是我们能不能这么想：既然文件与目录都是可以作为一个节点的下级节点而存在，那么我们可不可以将二者抽象为一类对象，虽然二者的操作不同，但是我们可以在实现类的方法实现中具体定义，比如文件没有新增下级节点的方法，我们就可以在文件的这个方法中抛出一个异常，不做具体实现，而在目录中则具体实现新增操作。显示操作二者都有，可以各自实现。而且由于我们将文件与目录抽象为一个类型，那么结合多态我们可以进行如下实现：

具体代码实现方式

抽象类：Node

/**
 * 将文件与目录统一看作是一类节点，做一个抽象类来定义这种节点，然后以其实现类来区分文件与目录，在实现类中分别定义各自的具体实现内容
 */
public abstract class Node {
    protected String name;//名称
    //构造器赋名
    public Node(String name){
        this.name = name;
    }
    //新增节点：文件节点无此方法，目录节点重写此方法
    public void addNode(Node node) throws Exception{
        throw new Exception("Invalid exception");
    }
    //显示节点：文件与目录均实现此方法
    abstract void display();
}

文件实现类：Filer

/**
 * 实现文件节点
 */
public class Filer extends Node {
    //通过构造器为文件节点命名
    public Filer(String name) {
        super(name);
    }
    //显示文件节点
    @Override
    public void display() {
        System.out.println(name);
    }
}

目录实现类：Noder

import java.util.*;
/**
 * 实现目录节点
 */
public class Noder extends Node {
    List<Node> nodeList = new ArrayList<Node>();//内部节点列表（包括文件和下级目录）
    //通过构造器为当前目录节点赋名
    public Noder(String name) {
        super(name);
    }
    //新增节点
    public void addNode(Node node) throws Exception{
        nodeList.add(node);
    }
    //递归循环显示下级节点
    @Override
    void display() {
        System.out.println(name);
        for(Node node:nodeList){
            node.display();
        }
    }
}

测试类：Clienter

import java.io.File;

public class Clienter {
    public static void createTree(Node node) throws Exception{
        File file = new File(node.name);
        File[] f = file.listFiles();
        for(File fi : f){
            if(fi.isFile()){
                Filer filer = new Filer(fi.getAbsolutePath());
                node.addNode(filer);
            }
            if(fi.isDirectory()){
                Noder noder = new Noder(fi.getAbsolutePath());
                node.addNode(noder);
                createTree(noder);//使用递归生成树结构
            }
        }
    }
    public static void main(String[] args) {
        Node noder = new Noder("E://ceshi");
        try {
            createTree(noder);
        } catch (Exception e) {
            e.printStackTrace();
        }
        noder.display();
    }
}

运行结果：

E://ceshi
E:\ceshi\文件1.txt
E:\ceshi\目录1
E:\ceshi\目录1\文件2.txt
E:\ceshi\目录1\目录3
E:\ceshi\目录2
E:\ceshi\目录2\文件3.txt

从上述实现中可以看出：所谓组合模式，其实说的是对象包含对象的问题，通过组合的方式（在对象内部引用对象）来进行布局，我认为这种组合是区别于继承的，而另一层含义是指树形结构子节点的抽象（将叶子节点与数枝节点抽象为子节点），区别于普通的分别定义叶子节点与数枝节点的方式。

4. 组合模式的优缺点

优点：

1. 可以清楚地定义分层次的复杂类型，表示对象的全部层次或者部分层次 ，它让客户端忽略了层次的差异，方便对整个层次经行控制。
2. 客户端可以一致的使用一个组合模式或对单个对象，不必关心处理的是单个对象还是整个组合结构，简化了客户端的代码。
3. 在组合模式种增加新的容器构件和叶子构件都很方便，无需对现有类库进行任何修改，符合开闭原则。
4. 为树形结构的面向对象实现提供了一种灵活的解决方案，通过叶子对象和容器对象的递归组合可以形成复杂的树形机构，但对树形结构的控制却很简单。

缺点：

1. 在增加新的构件时就比较难咯。而且难以限定，有时候希望在一个容器种能有某些特定的对象，例如在某个文件夹只能有image或者gif等。这个就比较难以实现。

5. 组合模式适用场景

1. 在具有整体和部分的层次结构种希望通过一种忽略整体与个体之间差异的，客户端一致对待的情况。
2. 在一个使用面向对象语言开发的系统中需要处理一个树形结构的。
3. 在一个系统中能分离出叶子和容器的，而且他们的类型还固定不变，需要增加一些新的类型