组合模式

3人阅读 评论(0) 收藏 举报
分类:

转载自 设计模式学习笔记-组合模式

1. 概述

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

2. 解决的问题

  当希望忽略单个对象和组合对象的区别,统一使用组合结构中的所有对象(将这种“统一”性封装起来)。

3. 组合模式中的角色

  3.1 组合部件(Component):它是一个抽象角色,为要组合的对象提供统一的接口。

  3.2 叶子(Leaf):在组合中表示子节点对象,叶子节点不能有子节点。

  3.3 合成部件(Composite):定义有枝节点的行为,用来存储部件,实现在Component接口中的有关操作,如增加(Add)和删除(Remove)。

4. 模式解读

  4.1 组合模式的类图

  

  4.2 组合模式的实现代码

复制代码
    /// <summary>
    /// 一个抽象构件,声明一个接口用于访问和管理Component的子部件
    /// </summary>
    public abstract class Component
    {
        protected string name;

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

        /// <summary>
        /// 增加一个节点
        /// </summary>
        /// <param name="component"></param>
        public abstract void Add(Component component);

        /// <summary>
        /// 移除一个节点
        /// </summary>
        /// <param name="component"></param>
        public abstract void Remove(Component component);

        /// <summary>
        /// 显示层级结构
        /// </summary>
        public abstract void Display(int level);
    }

    /// <summary>
    /// 叶子节点
    /// </summary>
    public class Leaf : Component
    {
        public Leaf(string name)
            : base(name)
        { }

        /// <summary>
        /// 由于叶子节点没有子节点,所以Add和Remove方法对它来说没有意义,但它继承自Component,这样做可以消除叶节点和枝节点对象在抽象层次的区别,它们具备完全一致的接口。
        /// </summary>
        /// <param name="component"></param>
        public override void Add(Component component)
        {
            Console.WriteLine("Can not add a component to a leaf.");
        }

        /// <summary>
        /// 实现它没有意义,只是提供了一个一致的调用接口
        /// </summary>
        /// <param name="component"></param>
        public override void Remove(Component component)
        {
            Console.WriteLine("Can not remove a component to a leaf.");
        }

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

    /// <summary>
    /// 定义有枝节点的行为,用来存储部件,实现在Component接口中对子部件有关的操作
    /// </summary>
    public class Composite : Component
    {
        public Composite(string name)
            : base(name)
        { }

        /// <summary>
        /// 一个子对象集合,用来存储其下属的枝节点和叶节点
        /// </summary>
        private List<Component> children = new List<Component>();

        /// <summary>
        /// 增加子节点
        /// </summary>
        /// <param name="component"></param>
        public override void Add(Component component)
        {
            children.Add(component);
        }

        /// <summary>
        /// 移除子节点
        /// </summary>
        /// <param name="component"></param>
        public override void Remove(Component component)
        {
            children.Remove(component);
        }

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

            // 遍历其子节点并显示
            foreach (Component component in children)
            {
                component.Display(level+2);
            }
        }
    }
复制代码

  4.3 客户端代码

复制代码
    class Program
    {
        static void Main(string[] args)
        {
            // 生成树根,并为其增加两个叶子节点
            Component root = new Composite("Root");
            root.Add(new Leaf("Leaf A in Root"));
            root.Add(new Leaf("Leaf B in Root"));

            // 为根增加两个枝节点
            Component branchX = new Composite("Branch X in Root");
            Component branchY = new Composite("Branch Y in Root");
            root.Add(branchX);
            root.Add(branchY);

            // 为BranchX增加页节点
            branchX.Add(new Leaf("Leaf A in Branch X"));

            // 为BranchX增加枝节点
            Component branchZ = new Composite("Branch Z in Branch X");
            branchX.Add(branchZ);

            // 为BranchY增加叶节点
            branchY.Add(new Leaf("Leaf in Branch Y"));

            // 为BranchZ增加叶节点
            branchZ.Add(new Leaf("Leaf in Branch Z"));

            // 显示树
            root.Display(1);

            Console.Read();
        }
    }
复制代码

  运行结果

  

5. 透明方式与安全方式

  5.1 透明方式:在Component中声明所有来管理子对象的方法,其中包括Add,Remove等。这样实现Component接口的所有子类都具备了Add和Remove方法。这样做的好处是叶节点和枝节点对于外界没有区别,它们具备完全一致的接口。

  5.2 安全方式:在Component中不去声明Add和Remove方法,那么子类的Leaf就不需要实现它,而是在Composit声明所有用来管理子类对象的方法。

  5.3 两种方式有缺点:对于透明方式,客户端对叶节点和枝节点是一致的,但叶节点并不具备Add和Remove的功能,因而对它们的实现是没有意义的;对于安全方式,叶节点无需在实现Add与Remove这样的方法,但是对于客户端来说,必须对叶节点和枝节点进行判定,为客户端的使用带来不便。

6. 模式总结

  6.1 优点

    6.1.1 使客户端调用简单,它可以一致使用组合结构或是其中单个对象,简化了客户端代码。

    6.1.2 容易在组合体内增加对象部件。客户端不必因加入了新的部件而更改代码。有利于功能的扩展。

  6.2 缺点

    6.2.1 需要抉择使用透明方式还是安全方式。

    6.2.2 透明方式违背了面向对象的单一职责原则;安全方式增加了客户需要端判定的负担。

  6.3 适用场景

    6.3.1 当想表达对象的部分-整体的层次结构时

    6.3.3 希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象时。


查看评论

结构型模式之——组合模式

结构型模式之 组合模式 前言 模式定义 模式结构 UML类图 适用场景 在以下情况下可以使用组合模式 看看大神怎么用 高清有码 总结 感谢结构型模式之 组合模式前言对于树形结构,在代码中有容器节点和叶...
  • u012984054
  • u012984054
  • 2016-08-18 01:00:53
  • 1213

深入浅出组合模式

一、引子在大学的数据结构这门课上,树是最重要的章节之一。还记得树是怎么定义的吗?树(Tree)是n(n≥0)个结点的有限集T,T为空时称为空树,否则它满足如下两个条件:(1)    有且仅有一个特定的...
  • ai92
  • ai92
  • 2005-02-23 10:33:00
  • 16003

C#设计模式08-组合模式

组合模式,又称之为“部分-整体”模式,属于对象结构型模式。在介绍组合模式之前,先来看一张图片。 这是我们操作系统中资源管理器的目录结构,其中有四个文件夹,四个文件。在组合模式中,文件夹就相当于容器构...
  • bhdxmaomi
  • bhdxmaomi
  • 2016-02-17 14:15:09
  • 799

JAVA设计模式初探之组合模式

先看看组合模式的定义吧:“将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。”    就拿剪发办卡的事情来分析一下吧。    首先,一张卡可...
  • jason0539
  • jason0539
  • 2014-03-31 08:40:06
  • 25172

组合模式(Composite Pattern )

当我想去了解组合模式的时候,网上搜一下,有很多优秀的文章,但很多人都在直接给出了组合模式的UML图,然后就去讲解什么是组合,组合有什么优缺点。 我承认他们也许讲的很好,但我并没有一下子就能理解了组合...
  • caiwenfeng_for_23
  • caiwenfeng_for_23
  • 2012-12-31 15:08:56
  • 8344

设计模式--组合模式java例子

  • 2017年02月18日 22:12
  • 20KB
  • 下载

对于组合模式的理解

今天看了组合模式 ,多用于树形结构 定义:  组合模式(Composite Pattern):组合多个对象形成树形结构以表示具有“整体—部分”关系的层次结构。组合模式对单个对象(即叶子对象)和组合对象...
  • AlbertFly
  • AlbertFly
  • 2016-06-16 12:14:39
  • 3367

Java 设计模式——组合模式

有时我们可能会被要求处理一个层级结构明显的对象,比如上下级的公司员工、比如层级嵌套的文件夹,还有丰富多彩的美食菜单。可是,我们可能要屡试不爽地编写深度搜索代码、要小心翼翼地编写递归逻辑。现在你可以忘掉...
  • u013761665
  • u013761665
  • 2016-05-17 17:39:45
  • 8122

【JS设计模式】装饰者模式和组合模式两者很像,那么这二者之间又有什么区别呢?

装饰者模式可以用来透明地把对象包装在具有同样接口的另一个对象中。这样一来,你可以给一个方法加一些行为,然后将方法调用传递给原始对象。相对于创建子类来说,使用装饰者对象是一种更灵活的选择。装饰者模式和结...
  • itpinpai
  • itpinpai
  • 2016-06-02 15:34:41
  • 3711

组合模式(Composite Pattern)(一):组合模式介绍

一、意图 将对象组合成树形结构以表示“部分-整体”的层次结构。Composite模式使得用户对单个对象和组合对象的使用具有一致性。 二、适用性 • 你想表示对象的...
  • jialinqiang
  • jialinqiang
  • 2013-05-20 22:30:49
  • 3772
    个人资料
    持之以恒
    等级:
    访问量: 1万+
    积分: 469
    排名: 2万+
    文章存档