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\目录1
E:\ceshi\目录1\目录3
E:\ceshi\目录1\文件2.txt
E:\ceshi\目录2
E:\ceshi\目录2\文件3.txt
E:\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     @Override
11     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     @Override
17     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://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

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

3、组合模式应用场景

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

 

    原文作者:唯一浩哥
    原文地址: https://www.cnblogs.com/V1haoge/p/6489827.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注