设计模式----组合模式_符号组合模式-CSDN博客

本文链接：https://blog.csdn.net/tang_huan_11/article/details/8236002

学习一些东西,我总感觉不整理一下笔记,总是感觉在脑海里没有记忆,我喜欢在学习完一定时间内,整理一下自己的

笔记,我感觉这是一笔很大的财富.

今天我就贴贴我的设计模式---组合模式的笔记!

我们先来看一下在我们使用电脑中常用到的一些组合关系,不知道大家平时注意了没有!

第一组,打开电脑,左侧栏的显示:

2,OneNote右侧的页,父页与子页

学习总是会想到生活中的一些常用的事物,学习离不开生活,在我们的生活中,还有很多地方用到组合模式,比如说公

司与子公司,提高班的公司制度等,

这些都是在生活中的组合模式,我们来认识一下官方的组合模式.

组合模式(Composite),将对象组合成树形结构以表示'部分--整体'的层次结构.组合模式使得用户对单个对

象的使用具有一致性.

要点:

1.组合模式以不遵守单一责任原则换取透明性,让Client将组合和叶节点一视同仁.

2.在实现组合模式时,有哦获得设计上的折衷,要根据需求平衡透明性和安全性.

3.有时候系统需要遍历一个树枝构件的子构件很多次,这时候可以把遍历结构缓存起来,

4.组合模式的实现中,可以让子对象持有父对象的引用进行反向追溯

类图:

Component(抽象构建角色):是组合中的对象声明接口,在适当情况下,实现所有类共有接口的默认行为,声明一个接口用

于访问和管理Component的子部件.这个接口可以用来管理所有的子对象.

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

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

Client(客户端):通过compnonent接口操纵组合部件的对象.

实现代码:

namespace 组合模式
{
    /// <summary>
    /// Component为组合中的对象声明接口,在适当情况下,是吸纳素有类共有接口的默认行为.
    /// </summary>
    /// 声明一个接口用于访问Component的子部件
    /// 
    abstract class Compnonent
    {
        protected string name;

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

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

    /// <summary>
    /// Leaf类,表示叶节点对象,叶节点没有子节点.
    /// </summary>
    /// 
    class Leaf : Compnonent
    {
        public Leaf(string name)
            : base(name)
        {
        }

        public override void Add(Compnonent c)
        {
            Console.WriteLine("Cannot add to a leaf");
        }

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

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


    /// <summary>
    /// Composite定义有枝节点行为,用存储子部件.
    /// </summary>
    /// 
    class COmposite : Compnonent
    {
        private List<Compnonent> children = new List<Compnonent>();

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

        public override void Add(Compnonent c)
        {

            children.Add(c);
        }

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

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

            foreach( Compnonent  component in children )
            {
                component .Display (depth+2);
            }
        }
    }
    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 comp1 = new COmposite("Composite XY");
            comp1.Add(new Leaf("Leaf XYA"));
            comp1.Add(new Leaf("Leaf XYB"));

            comp.Add(comp1);

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

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

            root.Display(1);

            Console.Read();
            
        }
    }
}

结果: