zoukankan      html  css  js  c++  java
  • 设计模式(十)组合(结构型)

    概述                                                                            

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

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

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

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

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

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

    分类                                                                            

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

    适用                                                                           

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

     类图                                                                           

     

    角色                                                                           

    抽象构件角色(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 + "	职位" + position + "	薪水" + 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 + "	职位" + position + "	薪水" + 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("
    "+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

  • 相关阅读:
    java并发容器
    五种单例模式的写法
    Java中Volatile关键字
    Future模式实例
    mysql笔记
    亚马逊EC2服务器登录方法
    RSA加密方法java工具类
    Base64Util工具类
    maven命令创建项目
    关于spring事务注解
  • 原文地址:https://www.cnblogs.com/yydcdut/p/3897374.html
Copyright © 2011-2022 走看看