`
terryfeng
  • 浏览: 504830 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

组合模式(Composite)

阅读更多

重要概念

1. 将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

image

2. 透明方式与安全方式

透明方式:抽象层接口最大化

安全方式:抽象层接口最小化

image

3.需求中是体现部分和整体层次的结构时,以及你希望用户可以忽略组合对象与单个对象的不同,统一地使用组合结构中的所有对象时,就应该考虑用组合模式了。

4. 组合模式的核心技巧是,模拟一个数型结构,其中的元素具有相同的抽象,抽象中拥有添加和删除子节点的功能,每个节点本身要维护一个子节点的列表,有了这个结构之后就可以维护一组数型结构。

5. 组合模式可以无限极的组合对象,具有相同接口的抽象。客户无需去判断叶子节点和树干节点,因为叶子节点只需不实现添加和移除子节点的功能即可。

6.

7.

 

 

示例代码

using System;
using System.Collections.Generic;
using System.Text;

namespace 组合模式
{
    class Program
    {
        static void Main(string[] args)
        {
            Composite root = new Composite("root");
            root.Add(new Leaf("Leaf A"));
            root.Add(new Leaf("Leaf B"));

            Composite comp = new Composite("Composite X");
            comp.Add(new Leaf("Leaf XA"));
            comp.Add(new Leaf("Leaf XB"));

            root.Add(comp);

            Composite comp2 = new Composite("Composite XY");
            comp2.Add(new Leaf("Leaf XYA"));
            comp2.Add(new Leaf("Leaf XYB"));

            comp.Add(comp2);

            root.Add(new Leaf("Leaf C"));

            Leaf leaf = new Leaf("Leaf D");
            root.Add(leaf);
            root.Remove(leaf);

            root.Display(1);

            Console.Read();
        }
    }

    /// <summary>
    /// 抽象类
    /// </summary>
    abstract class Component
    {
        protected string name;

        public Component(string name)
        {
            this.name = name;
        }

        //通过Add和REmove方法提供增加和删除树节点的功能
        public abstract void Add(Component c);

        public abstract void Remove(Component c);
        public abstract void Display(int depth);
    }

    class Composite : Component
    {
        //这个子对象集合用来存储其下的节点
        private List<Component> children = new List<Component>();

        public Composite(string name)
            : base(name)
        { }

        public override void Add(Component c)
        {
            children.Add(c);
        }

        public override void Remove(Component c)
        {
            children.Remove(c);
        }

        /// <summary>
        /// 显示自己,也显示其下的子节点遍历
        /// </summary>
        /// <param name="depth"></param>
        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);

            foreach (Component component in children)
            {
                component.Display(depth + 2);
            }
        }
    }

    class Leaf : Component
    {
        public Leaf(string name)
            : base(name)
        { }

        /// <summary>
        /// Leaf中没有子节点,实现添加和移除是没有意义的,但是继承统一的接口保持一致。
        /// </summary>
        /// <param name="c"></param>
        public override void Add(Component c)
        {
            Console.WriteLine("Cannot add to a leaf");
        }

        public override void Remove(Component c)
        {
            Console.WriteLine("Cannot remove from a leaf");
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
        }
    }
}

 

公司管理系统

image

using System;
using System.Collections.Generic;
using System.Text;

namespace 组合模式
{
    class Program
    {
        static void Main(string[] args)
        {
            ConcreteCompany root = new ConcreteCompany("北京总公司");
            root.Add(new HRDepartment("总公司人力资源部"));
            root.Add(new FinanceDepartment("总公司财务部"));

            ConcreteCompany comp = new ConcreteCompany("上海华东分公司");
            comp.Add(new HRDepartment("华东分公司人力资源部"));
            comp.Add(new FinanceDepartment("华东分公司财务部"));
            root.Add(comp);

            ConcreteCompany comp1 = new ConcreteCompany("南京办事处");
            comp1.Add(new HRDepartment("南京办事处人力资源部"));
            comp1.Add(new FinanceDepartment("南京办事处财务部"));
            comp.Add(comp1);

            ConcreteCompany comp2 = new ConcreteCompany("杭州办事处");
            comp2.Add(new HRDepartment("杭州办事处人力资源部"));
            comp2.Add(new FinanceDepartment("杭州办事处财务部"));
            comp.Add(comp2);


            Console.WriteLine("\n结构图:");

            root.Display(1);

            Console.WriteLine("\n职责:");

            root.LineOfDuty();


            Console.Read();
        }
    }

    abstract class Company
    {
        protected string name;

        public Company(string name)
        {
            this.name = name;
        }

        public abstract void Add(Company c);//增加
        public abstract void Remove(Company c);//移除
        public abstract void Display(int depth);//显示
        public abstract void LineOfDuty();//履行职责

    }

    class ConcreteCompany : Company
    {
        private List<Company> children = new List<Company>();

        public ConcreteCompany(string name)
            : base(name)
        { }

        public override void Add(Company c)
        {
            children.Add(c);
        }

        public override void Remove(Company c)
        {
            children.Remove(c);
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);

            foreach (Company component in children)
            {
                component.Display(depth + 2);
            }
        }

        //履行职责
        public override void LineOfDuty()
        {
            foreach (Company component in children)
            {
                component.LineOfDuty();
            }
        }

    }

    //人力资源部
    class HRDepartment : Company
    {
        public HRDepartment(string name)
            : base(name)
        { }

        public override void Add(Company c)
        {
        }

        public override void Remove(Company c)
        {
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
        }


        public override void LineOfDuty()
        {
            Console.WriteLine("{0} 员工招聘培训管理", name);
        }
    }

    //财务部
    class FinanceDepartment : Company
    {
        public FinanceDepartment(string name)
            : base(name)
        { }

        public override void Add(Company c)
        {
        }

        public override void Remove(Company c)
        {
        }

        public override void Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
        }

        public override void LineOfDuty()
        {
            Console.WriteLine("{0} 公司财务收支管理", name);
        }

    }
}
分享到:
评论

相关推荐

    组合模式 Composite Pattern

    **组合模式**(Composite Pattern)是一种常用的结构型设计模式,主要用于构建具有层次结构的对象系统。它允许客户端以一致的方式处理单个对象和组合对象,简化了高层模块的调用。通过组合模式,可以将多个对象组织成...

    设计模式之组合模式(Composite Pattern)

    组合模式是一种行为设计模式,属于面向对象设计中的结构型模式,其主要目的是为了建立一种对象树形结构,这种结构能够使客户端代码以统一的方式处理单个对象和对象的组合。在组合模式中,我们通常会定义一个基类,...

    设计模式C++学习之组合模式(Composite)

    组合模式是一种结构型设计模式,它允许我们使用树形结构来表示部分-整体关系,使得我们能够以统一的方式处理单个对象和对象集合。在C++中,组合模式的应用可以帮助我们构建灵活且易于操作的对象层次结构,使得客户端...

    c++-设计模式之组合模式(Composite Pattern)

    组合模式(Composite Pattern)是一种结构型设计模式,用于将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得客户端可以以统一的方式对待单个对象和组合对象,这种模式常用于需要处理树形结构的数据...

    PHP设计模式(七)组合模式Composite实例详解【结构型】

    【PHP设计模式】组合模式(Composite)是一种结构型设计模式,它主要解决的是在处理具有树形结构的数据时,如何让客户端代码能够统一地处理单个对象和对象的集合,而无需关注它们的区别。组合模式将对象组织成树形...

    Java24种设计模式,Java24种设计模式,24种设计模式,学会了这24种设计模式,可以打遍天下无敌手,设计模式非常重要

    15、组合模式COMPOSITE PATTERN 16、观察者模式OBSERVER PATTERN 17、责任链模式 18、访问者模式VISITOR PATTERN 19、状态模式 20、原型模式 21、中介者模式 22、解释器模式 23、亨元模式 24、备忘录模式

    Composite Pattern(组合模式)

    **组合模式(Composite Pattern)详解** 组合模式是一种结构型设计模式,它将对象组织成树形结构,使得用户可以对单个对象和对象集合进行统一操作。这种模式在处理部分与整体关系时非常有用,允许我们一致地处理...

    组合模式(Composite Pattern)原理图

    组合模式(Composite Pattern)是一种对象结构型模式,其定义是将多个对象组合成树形结构以表示“整体-部分”关系的层次结构。它使得客户端对单个对象和组合对象的使用具有一致性。在组合模式中,对象被组织成树形...

    设计模式_组合模式.zip

    组合模式(Composite Pattern),又叫部分整体模式,是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象,用来表示部分以及整体层次。这种类型的设计模式属于结构型模式,它创建了对象组的...

    设计模式面面观(11):组合模式(Composite Pattern)-结构型模式

    **设计模式面面观:组合模式(Composite Pattern)** 组合模式是软件工程中的一种结构型设计模式,它允许我们以树形结构来表示部分与整体的关系,使得客户端代码可以一致地处理单个对象和对象组合。在组合模式中,...

    java常用设计模式-组合模式

    组合模式(Composite Pattern)是一种结构型设计模式,它允许你将对象组合成树形结构以表示“部分-整体”的层次结构。这种模式使得客户端可以统一对待单个对象和对象组合。在组合模式中,有两种基本类型的对象:叶...

    C++设计模式课件20_Composite_组合模式.pdf

    组合模式(Composite Pattern)是一种树形结构的设计模式,它将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户可以对单个对象和组合对象进行一致性的操作处理,即客户程序可以像操作单个对象...

    组合模式代码示例

    组合模式是一种设计模式,属于结构型模式,它允许我们以统一的方式处理单个对象和对象的集合。在软件工程中,这种模式常用于构建树形结构,使得客户端代码可以一致地处理单个对象和组合对象,而无需关心它们的具体...

    组合模式-五子棋代码.zip

    组合模式是一种对象结构型设计模式,它允许我们以树形结构来表示部分-整体关系,使得我们可以像处理单个对象一样处理整个集合。在五子棋游戏的实现中,组合模式的应用尤为关键,因为它帮助我们将棋盘上的棋子和棋盘...

    C#面向对象设计模式纵横谈(9):Composite 组合模式(结构型模式)

    在组合模式中,我们定义了两个主要的角色:Component(组件)和Composite(组合)。Component 是一个抽象基类,为所有对象(无论是基本元素还是复合元素)定义公共接口。Composite 类实现了 Component 接口,并且...

    设计模式实验报告-组合模式.docx

    组合模式(Composite Pattern)是一种结构型设计模式,它允许用户将对象组合成树形结构来表示部分-整体层次结构。该模式使得用户对单个对象和组合对象的使用具有一致性。 #### 实验内容 实验内容主要包括设计和实现...

    Objective C 组合模式设计源码

    组合模式(Composite),将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。 组合模式的适用场合是,一般当你发现需求中是体现部分与整体层次的结构时,...

Global site tag (gtag.js) - Google Analytics