【设计模式】8、组合模式

package com.shejimoshi.structural.Composite.type1;


/**
 * 功能：将对象组合成树形结构以表示“部分-整体”的层次结构。composite使得用户对单个对象和组合对象的使用具有一致性
 * 适用：想表示对象的部分-整体层次结构
 *         希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象
 * 时间：2016年2月20日下午8:57:12
 * 作者：cutter_point
 */
public abstract class Componment
{
    protected String name;    //名字
    
    public Componment(String name)
    {
        this.name = name;
    }
    
    //几个基本的方法，叶子节点和枝节点都需要的，叶子节点没有子节点
    public abstract void add(Componment c);
    public abstract void remove(Componment c);
    public abstract void display(int depth);    //当前的深度
}

这里再display的时候，有部分代码很重复，我觉得麻烦，我就在封装了一个方法

package com.shejimoshi.structural.Composite.type1;


/**
 * 功能：工具类
 * 时间：2016年2月20日下午9:12:54
 * 作者：cutter_point
 */
public class myutil
{
    public static StringBuffer show(int depth)
    {
        //显示名称和深度就可以了
        StringBuffer sb = new StringBuffer();
        for(int i = 0; i < depth; ++i)
            sb.append("-");
        
        return sb;
    }
}

叶子

package com.shejimoshi.structural.Composite.type1;


/**
 * 功能：将对象组合成树形结构以表示“部分-整体”的层次结构。composite使得用户对单个对象和组合对象的使用具有一致性
 * 适用：想表示对象的部分-整体层次结构
 *         希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象
 * 时间：2016年2月20日下午9:02:24
 * 作者：cutter_point
 */
public class Leaf extends Componment
{

    public Leaf(String name)
    {
        super(name);
    }

    @Override
    public void add(Componment c)
    {
        //叶子是没有子类的，他是叶子，所以添加和移除没有意义
        System.out.println("添加错误，叶子节点");
    }

    @Override
    public void remove(Componment c)
    {
        //叶子是没有子类的，他是叶子，所以添加和移除没有意义
        System.out.println("删除错误，叶子节点");
    }

    @Override
    public void display(int depth)
    {
        //显示名称和深度就可以了
        StringBuffer sb = myutil.show(depth);
        sb.append(this.name);
        System.out.println(sb.toString());
    }

}

分支节点

package com.shejimoshi.structural.Composite.type1;

import java.util.ArrayList;
import java.util.List;


/**
 * 功能：将对象组合成树形结构以表示“部分-整体”的层次结构。composite使得用户对单个对象和组合对象的使用具有一致性
 * 适用：想表示对象的部分-整体层次结构
 *         希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象
 * 时间：2016年2月20日下午9:09:45
 * 作者：cutter_point
 */
public class Composite extends Componment
{
    //这个是单个节点，树枝节点，可以有子节点，我们用一个list存放我们的孩子节点
    private List<Componment> children = new ArrayList<Componment>();
    
    public Composite(String name)
    {
        super(name);
    }

    @Override
    public void add(Componment c)
    {
        //添加一个孩子节点
        children.add(c);
    }

    @Override
    public void remove(Componment c)
    {
        //删除对应的节点
        children.remove(c);
    }

    @Override
    public void display(int depth)
    {
        //首先显示当前节点信息
        StringBuffer sb = myutil.show(depth);
        sb.append(this.name);
        System.out.println(sb.toString());
        
        //显示相应的叶子的属性
        for(Componment c : children)
        {
            //吧深度添加一个标准
            c.display(depth + 2);
        }//for
    }

}

测试代码：

package com.shejimoshi.structural.Composite.type1;


/**
 * 功能：测试组合模式
 * 时间：2016年2月20日下午9:15:49
 * 作者：cutter_point
 */
public class Test
{
    public static void main(String[] args)
    {
        Composite root = new Composite("根");
        root.add(new Leaf("叶子A1"));
        root.add(new Leaf("叶子A2"));
        root.add(new Leaf("叶子A3"));
        
        //第一个分支
        Composite child1 = new Composite("分支A1");
        child1.add(new Leaf("叶子B1"));
        child1.add(new Leaf("叶子B2"));
        
        root.add(child1); //吧分支加进去
        
        //分支可以再有分支,分支2
        Composite child2 = new Composite("分支B1");
        child2.add(new Leaf("叶子C1"));
        child2.add(new Leaf("叶子C2"));
        
        child1.add(child2);
        
        //根部在张叶子
        root.add(new Leaf("叶子A4"));
        Leaf leaf = new Leaf("叶子A5");
        root.add(leaf);
        root.remove(leaf);
        
        //显示大树，首先大树根，那么深度就是0
        root.display(0);
    }
}

结果：

根
--叶子A1
--叶子A2
--叶子A3
--分支A1
----叶子B1
----叶子B2
----分支B1
------叶子C1
------叶子C2
--叶子A4