java组合模式

原文链接：http://www.cnblogs.com/V1haoge/p/6489827.html

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

1、我们首先来看一个目录结构的普通实现：

目录节点：Noder

 1 import java.util.ArrayList; 2 import java.util.List; 3 /** 4  * 目录节点 5  * 包含： 6  *         1、目录名 7  *         2、下级文件列表 8  *         3、下级目录列表 9  *         4、新增文件方法10  *         5、新增目录方法11  *         6、显示下级内容方法12  */13 public class Noder {14     String nodeName;//目录名15     //通过构造器为目录命名16     public Noder(String nodeName){17         this.nodeName = nodeName;18     }19     List<Noder> nodeList = new ArrayList<Noder>();//目录的下级目录列表20     List<Filer> fileList = new ArrayList<Filer>();//目录的下级文件列表21     //新增下级目录22     public void addNoder(Noder noder){23         nodeList.add(noder);24     }25     //新增文件26     public void addFiler(Filer filer){27         fileList.add(filer);28     }29     //显示下级目录及文件30     public void display(){31         for(Noder noder:nodeList){32             System.out.println(noder.nodeName);33             noder.display();//递归显示目录列表34         }35         for(Filer filer:fileList){36             filer.display();37         }38     }39 }

文件节点：Filer

 1 /** 2  * 文件节点 3  * 文件节点是终节点，无下级节点 4  * 包含： 5  *         1、文件名 6  *         2、文件显示方法 7  */ 8 public class Filer { 9     String fileName;//文件名10     public Filer(String fileName){11         this.fileName = fileName;12     }13     //文件显示方法14     public void display(){15         System.out.println(fileName);16     }17 }

测试类：Clienter

 1 import java.io.File; 2  3 public class Clienter { 4     public static void createTree(Noder node){ 5         File file = new File(node.nodeName); 6         File[] f = file.listFiles(); 7         for(File fi : f){ 8             if(fi.isFile()){ 9                 Filer filer = new Filer(fi.getAbsolutePath());10                 node.addFiler(filer);11             }12             if(fi.isDirectory()){13                 Noder noder = new Noder(fi.getAbsolutePath());14                 node.addNoder(noder);15                 createTree(noder);//使用递归生成树结构16             }17         }18     }19     public static void main(String[] args) {20         Noder noder = new Noder("E://ceshi");21         createTree(noder);//创建目录树形结构22         noder.display();//显示目录及文件23     }24 }

运行结果：

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

2、组合模式

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

抽象类：Node

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

文件实现类：Filter

 1 /** 2  * 实现文件节点 3  */ 4 public class Filer extends Node { 5     //通过构造器为文件节点命名 6     public Filer(String name) { 7         super(name); 8     } 9     //显示文件节点10     @Override11     public void display() {12         System.out.println(name);13     }14 }

目录实现类：Noder

 1 import java.util.*; 2 /** 3  * 实现目录节点 4  */ 5 public class Noder extends Node { 6     List<Node> nodeList = new ArrayList<Node>();//内部节点列表（包括文件和下级目录） 7     //通过构造器为当前目录节点赋名 8     public Noder(String name) { 9         super(name);10     }11     //新增节点12     public void addNode(Node node) throws Exception{13         nodeList.add(node);14     }15     //递归循环显示下级节点16     @Override17     void display() {18         System.out.println(name);19         for(Node node:nodeList){20             node.display();21         }22     }23 }

测试类：Clienter

 1 import java.io.File; 2  3 public class Clienter { 4     public static void createTree(Node node) throws Exception{ 5         File file = new File(node.name); 6         File[] f = file.listFiles(); 7         for(File fi : f){ 8             if(fi.isFile()){ 9                 Filer filer = new Filer(fi.getAbsolutePath());10                 node.addNode(filer);11             }12             if(fi.isDirectory()){13                 Noder noder = new Noder(fi.getAbsolutePath());14                 node.addNode(noder);15                 createTree(noder);//使用递归生成树结构16             }17         }18     }19     public static void main(String[] args) {20         Node noder = new Noder("E://ceshi");21         try {22             createTree(noder);23         } catch (Exception e) {24             e.printStackTrace();25         }26         noder.display();27     }28 }

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

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

3、组合模式应用场景

　　这种组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如：文件目录显示，多及目录呈现等树形结构数据的操作。