浅谈Composite组合模式

1、前言

关于Composite组合模式，这个模式在咱们的生活中也常常使用，好比说若是读者有使用java的GUI编写过程序的，确定少不了定义一些组件，初始化以后，使用容器的add方法，将这些组件有顺序的组织成一个界面出来；或者读者若是编写过前台的页面，确定使用过<div>等标签订义一些格式，而后格式之间互相组合，经过一种递归的方式组织成相应的结果，这种方式其实就是组合，将部分的组件镶嵌到总体之中；又或者文件和文件夹的组织关系，经过目录表项做为共同的特质（父类），一个文件夹能够包含多个文件夹和多个文件，一个文件容纳在一个文件夹中。那么凭什么能够这样作呢，须要知足一下两点：

• 总体的结果应该是一棵树
• 全部的组件应该有一个共同的父类

这个父类使得组件中的共同的本质能够提取出来，进行互融，其实就是父类只用add方法，这样子类就能够经过抽象的方式经过父类来表达了。

2、代码

Entry抽象类：共同特质

package zyr.dp.composite;

public abstract class Entry {
    public abstract String getName();
    public abstract int getSize();
    public abstract void printList(String prefix);
    public  void printList(){
        printList("");
    }
    public  Entry add(Entry entry) throws RuntimeException{
        throw new RuntimeException();
    }
    public  String toString(){
        return getName()+"<"+getSize()+">";
    }
}

File类：实现类，叶子结点

package zyr.dp.composite;

public class File extends Entry {

    private String name;
    private int size;
    public File(String name,int size){
        this.name=name;
        this.size=size;
    }
    public String getName() {
        return name;
    }

    public int getSize() {
        return size;
    }

    public void printList(String prefix) {
        System.out.println(prefix+"/"+this);
    }

}

Directory类：可扩充节点（中间节点）

package zyr.dp.composite;

import java.util.ArrayList;
import java.util.Iterator;

public class Directory extends Entry {

    String name;
    ArrayList entrys=new ArrayList();
    public Directory(String name){
        this.name=name;
    }
    public String getName() {
        return name;
    }

    public int getSize() {
        int size=0;
        Iterator it=entrys.iterator();
        while(it.hasNext()){
            size+=((Entry)it.next()).getSize();
        }
        return size;
    }

    public Entry add(Entry entry) {
        entrys.add(entry);
        return this;
    }
    
    public void printList(String prefix) {
        System.out.println(prefix+"/"+this);
        Iterator it=entrys.iterator();
        Entry entry;
        while(it.hasNext()){
            entry=(Entry)it.next();
            entry.printList(prefix+"/"+name);
        }
    }

}

Main类：组合组件

package zyr.dp.composite;

public class Main {

    public static void main(String[] args) {

        Directory root=new Directory("根目录");
        
        Directory life=new Directory("个人生活");
        File eat=new File("吃火锅",100);
        File sleep=new File("睡觉",100);
        File study=new File("学习",100);
        life.add(eat);
        life.add(sleep);
        life.add(study);
        
        Directory work=new Directory("个人工做");
        File write=new File("写博客",200);
        File paper=new File("写论文",200);
        File homework=new File("写家庭做业",200);
        work.add(write);
        work.add(paper);
        work.add(homework);
        
        Directory relax=new Directory("个人休闲");
        File music=new File("听听音乐",200);
        File walk=new File("出去转转",200);
        relax.add(music);
        relax.add(walk);
        
        Directory read=new Directory("个人阅读");
        File book=new File("学习书籍",200);
        File novel=new File("娱乐小说",200);
        read.add(book);
        read.add(novel);
        
        root.add(life);
        root.add(work);
        root.add(relax);
        root.add(read);

        root.printList("D:");
        System.out.println("=================");
        work.printList("work");
        System.out.println("=================");
        novel.printList("novel");
        

    }

}

运行结果：

3、总结

因而可知，咱们之前使用的“容器+内容”，实际上是经过组合模式实现的，组合模式保证了容器和内容的一致性，容器里面能够嵌套容器，也能够放内容，可是内容已是叶子结点了，不能继续扩充，还记得咱们在抽象工厂模式中，为了将零件组装成产品，咱们就使用了组合模式，很是的有意思，经过递归来遍历全部的内容。组合模式在咱们的生活中使用的很是广泛，咱们必定要使用好这个模式，理解其中的抽象，特别是add()的定义，抽象类和实现类之间的参数传递，这点相当重要，固然咱们又使用了模板方法和迭代器，但愿你们能明白模式之间的联系以及相互使用的道理。

 

浅谈设计模式<最通俗易懂的讲解>