码迷,mamicode.com
首页 > 其他好文 > 详细

设计模式(十)组合(结构型)

时间:2014-08-11 14:32:52      阅读:229      评论:0      收藏:0      [点我收藏+]

标签:style   blog   http   color   java   使用   os   io   

概述                                                                            

在数据结构里面,树结构是很重要,我们可以把树的结构应用到设计模式里面。

例子1:就是多级树形菜单。

例子2:文件和文件夹目录

将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性。 

有时候又叫做部分-整体模式,它使我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

组合模式让你可以优化处理递归或分级数据结构。有许多关于分级数据结构的例子,使得组合模式非常有用武之地。关于分级数据结构的一个普遍性的例子是你每次使 用电脑时所遇到的:文件系统。文件系统由目录和文件组成。每个目录都可以装内容。目录的内容可以是文件,也可以是目录。按照这种方式,计算机的文件系统就 是以递归结构来组织的。如果你想要描述这样的数据结构,那么你可以使用组合模式

分类                                                                            

  1. 将管理子元素的方法定义在Composite类中
  2. 将管理子元素的方法定义在Component接口中,这样Leaf类就需要对这些方法空实现。

适用                                                                           

  1. 你想表示对象的部分-整体层次结构
  2. 你希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象。

 类图                                                                           

bubuko.com,布布扣 

角色                                                                           

抽象构件角色(component):是组合中的对象声明接口,在适当的情况下,实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component子部件。

这个接口可  以用来管理所有的子对象。(可选)在递归结构中定义一个接口,用于访问一个父部件,并在合适的情况下实现它。  

树叶构件角色(Leaf):在组合树中表示叶节点对象,叶节点没有子节点。并在组合中定义图元对象的行为。

树枝构件角色(Composite):定义有子部件的那些部件的行为。存储子部件。在Component接口中实现与子部件有关的操作。

客户角色(Client):通过component接口操纵组合部件的对象。  

代码                                                                            

Company.java

package com.yydcdut;

public interface Company {
    public String getInfo();
}

树枝节点ConcreteCompany

package com.yydcdut;

import java.util.ArrayList;

public class ConcreteCompany implements Company {

    private ArrayList<Company> companyList = new ArrayList<Company>();
    private String name;
    private String position;
    private int salary;

    public ConcreteCompany(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info = "名称:" + name + "\t职位" + position + "\t薪水" + salary;
        return info;
    }

    public void add(Company company) {
        companyList.add(company);
    }

    public void remove(Company company) {
        companyList.remove(company);
    }

    public ArrayList<Company> getChild() {
        return companyList;
    }

}

叶子节点Eployee

package com.yydcdut;

public class Employee implements Company {

    private String name;
    private String position;
    private int salary;

    public Employee(String name, String position, int salary) {
        super();
        this.name = name;
        this.position = position;
        this.salary = salary;
    }

    @Override
    public String getInfo() {
        String info = "";
        info = "名称:" + name + "\t职位" + position + "\t薪水" + salary;
        return info;
    }

}

 测试:

package com.yydcdut;

public class Main {

    public static void main(String[] args) {
        //BOSS
        ConcreteCompany root = new ConcreteCompany("zhangsan","ceo",10000);
        //Manager
        ConcreteCompany developDep = new ConcreteCompany("sisi", "yanha", 8000);
        ConcreteCompany salesDep = new ConcreteCompany("wangwu", "xiaoshou", 8000);
        ConcreteCompany financeDep = new ConcreteCompany("maliu", "caiwu", 8000);
        //employee
        Employee e1 = new Employee("A", "yanfa", 3000);
        Employee e2 = new Employee("B", "yanfa", 4000);
        Employee e3 = new Employee("C", "yanfa", 5000);
        Employee e4 = new Employee("D", "yanfa", 6000);
        Employee e5 = new Employee("E", "xiaoshou", 3000);
        Employee e6 = new Employee("F", "xiaoshou", 4000);
        Employee e7 = new Employee("G", "xiaoshou", 5000);
        Employee e8 = new Employee("H", "xiaoshou", 3000);
        Employee e9 = new Employee("I", "caiwu", 3000);
        //tree
        root.add(developDep);
        root.add(salesDep);
        root.add(financeDep);
        developDep.add(e1);
        developDep.add(e2);
        developDep.add(e3);
        developDep.add(e4);
        salesDep.add(e5);
        salesDep.add(e6);
        salesDep.add(e7);
        salesDep.add(e8);
        financeDep.add(e9);
        System.out.println(root.getInfo());
        display(root);
    }
    
    public static void display(ConcreteCompany root)
    {
        for(Company c : root.getChild())
        {
            if(c instanceof Employee) 
            {
                System.out.println(c.getInfo());
            }
            else
            {
                System.out.println("\n"+c.getInfo());
                display((ConcreteCompany) c);
            }
        }
    }

}

结果:

名称:zhangsan    职位ceo    薪水10000

名称:sisi    职位yanha    薪水8000
名称:A    职位yanfa    薪水3000
名称:B    职位yanfa    薪水4000
名称:C    职位yanfa    薪水5000
名称:D    职位yanfa    薪水6000

名称:wangwu    职位xiaoshou    薪水8000
名称:E    职位xiaoshou    薪水3000
名称:F    职位xiaoshou    薪水4000
名称:G    职位xiaoshou    薪水5000
名称:H    职位xiaoshou    薪水3000

名称:maliu    职位caiwu    薪水8000
名称:I    职位caiwu    薪水3000

组合模式和其他相关模式                                             

  1. 装饰模式(Decorator模式)经常与Composite模式一起使用。当装饰和组合一起使用时,它们通常有一个公共的父类。因此装饰必须支持具有 Add、Remove和GetChild 操作的Component接口。
  2. Flyweight模式让你共享组件,但不再能引用他们的父部件。
  3. (迭代器模式)Itertor可用来遍历Composite。
  4. (观察者模式)Visitor将本来应该分布在Composite和Leaf类中的操作和行为局部化。

总结                                                                             

组合模式解耦了客户程序与复杂元素内部结构,从而使客户程序可以向处理简单元素一样来处理复杂元素。

如果你想要创建层次结构,并可以在其中以相同的方式对待所有元素,那么组合模式就是最理想的选择。

我是天王盖地虎的分割线                                            

源代码:http://pan.baidu.com/s/1dD1Qx01

java组合.zip

 

设计模式(十)组合(结构型),布布扣,bubuko.com

设计模式(十)组合(结构型)

标签:style   blog   http   color   java   使用   os   io   

原文地址:http://www.cnblogs.com/yydcdut/p/3897374.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!