结构型模式--组合模式（Composite）

组合模式有时又叫部分-整体模式在处理类似树形结构的问题时比较方便，看看关系图：

对象通过实现（继承）统一的接口（抽象类），调用者对单一对象和组合对象的操作具有一致性

直接来看代码：

[java]  view plain copy

1. public class TreeNode {  
2.       
3.     private String name;  
4.     private TreeNode parent;  
5.     private Vector<TreeNode> children = new Vector<TreeNode>();  
6.       
7.     public TreeNode(String name){  
8.         this.name = name;  
9.     }  
10.   
11.     public String getName() {  
12.         return name;  
13.     }  
14.   
15.     public void setName(String name) {  
16.         this.name = name;  
17.     }  
18.   
19.     public TreeNode getParent() {  
20.         return parent;  
21.     }  
22.   
23.     public void setParent(TreeNode parent) {  
24.         this.parent = parent;  
25.     }  
26.       
27.     //添加孩子节点  
28.     public void add(TreeNode node){  
29.         children.add(node);  
30.     }  
31.       
32.     //删除孩子节点  
33.     public void remove(TreeNode node){  
34.         children.remove(node);  
35.     }  
36.       
37.     //取得孩子节点  
38.     public Enumeration<TreeNode> getChildren(){  
39.         return children.elements();  
40.     }  
41. }  

[java]  view plain copy

1. public class Tree {  
2.   
3.     TreeNode root = null;  
4.   
5.     public Tree(String name) {  
6.         root = new TreeNode(name);  
7.     }  
8.   
9.     public static void main(String[] args) {  
10.         Tree tree = new Tree("A");  
11.         TreeNode nodeB = new TreeNode("B");  
12.         TreeNode nodeC = new TreeNode("C");  
13.           
14.         nodeB.add(nodeC);  
15.         tree.root.add(nodeB);  
16.         System.out.println("build the tree finished!");  
17.     }  
18. }  

使用场景：将多个对象组合在一起进行操作，常用于表示树形结构中，例如二叉树，数等。

 

2=====================================================

interface Node{  
    public void copy(); //定义统一的接口：复制  
}  
 
class Folder implements Node{  
    private String folderName;  
    private ArrayList nodeList =new ArrayList(); //用于存储文件夹下的文件夹或文件的信息 
 
    public Folder(String folderName){  
        this.folderName = folderName;  
    }  
 
    public void add(Node node){ //增加文件或文件夹  
        nodeList.add(node);  
    }  
 
    public void copy(){  //文件夹复制操作实现递归  
        System.out.println("复制文件夹：" + folderName);  
        for(int i=0;i
            Node node = (Node)nodeList.get(i);  
            node.copy();  
        }  
    }  
}  
 
class File implements Node{  
    private String fileName;  
 
    public File(String fileName){  
        this.fileName = fileName;  
    }  
 
    public void copy(){  
        System.out.println("复制文件：" + fileName);  
    }  
}  
 
public class Composite{  
    public static void main(String[] args){  
        Folder document = new Folder("我的资料"); //我的资料文件夹  
        File book = new File("Java编程思想.pdf");  //文档文件  
        Folder music = new Folder("我的音乐");   //我的音乐文件夹  
        File music1 = new File("你是我的眼.mp3");   //音乐文件1  
        File music2 = new File("Without You.mp3");  //音乐文件2  
        //确定树形结构关系  
        document.add(book);  
        document.add(music);  
        music.add(music1);  
        music.add(music2);  
 
        document.copy(); //复制“我的资料”文件夹，递归地复制了其下所有文件夹和文件。 
    }  
} 

 运行结果如下：

1. 复制文件夹：我的资料  
2. 复制文件：Java编程思想.pdf  
3. 复制文件夹：我的音乐  
4. 复制文件：你是我的眼.mp3  
5. 复制文件：Without You.mp3