摘要: 原创作品，可以转载，但是请标注出处地址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、组合模式应用场景
这种组合模式正是应树形结构而生，所以组合模式的使用场景就是出现树形结构的地方。比如：文件目录显示，多及目录呈现等树形结构数据的操作。
时间： 2024-10-10 16:02:37