设计模式——组合模式

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

组合模式的使用类似于树的结构。在树结构中主要有两类对象，一个是子节点，一个是父节点。

父节点中可以包含子节点，而子节点之下则不能拥有父节点。（比较适用在递归结构中）

以文件的资料夹为例：

按照正常理解，单个文件如图片格式，文本格式，文件夹我们应该每个都独立的抽象出一个类，在他们的具体类中进行相应的操作，

但是如此一来功能类就会有些冗余。借鉴代码如下：

图片类

   class ImageFile
    {
        private String name;

        public ImageFile(String name)
        {
            this.name = name;
        }

        public void killVirus() {  
        //简化代码，模拟杀毒  
       Console.WriteLine("----对图像文件'" + name + "'进行杀毒");  
    }  
    }

文本类

 class TextFile
    {
        private String name;

        public TextFile(String name)
        {
            this.name = name;
        }

        public void killVirus() {  
        //简化代码，模拟杀毒  
        Console.WriteLine("----对文本文件'" + name + "'进行杀毒");
    }  
    }

文件夹类

 class Folder
    {
        private String name;
        //定义集合folderList，用于存储Folder类型的成员  
        private List<Folder> folderList = new List<Folder>();
        //定义集合imageList，用于存储ImageFile类型的成员  
        private List<ImageFile> imageList = new List<ImageFile>();
        //定义集合textList，用于存储TextFile类型的成员  
        private List<TextFile> textList = new List<TextFile>();

        public Folder(String name)
        {
            this.name = name;
        }

        //增加新的Folder类型的成员  
        public void addFolder(Folder f)
        {
            folderList.Add(f);
        }

        //增加新的ImageFile类型的成员  
        public void addImageFile(ImageFile image)
        {
            imageList.Add(image);
        }

        //增加新的TextFile类型的成员  
        public void addTextFile(TextFile text)
        {
            textList.Add(text);
        }

        //需提供三个不同的方法removeFolder()、removeImageFile()和removeTextFile()来删除成员，代码省略  

        //需提供三个不同的方法getChildFolder(int i)、getChildImageFile(int i)和getChildTextFile(int i)来获取成员，代码省略  

        public void killVirus() {  
        Console.WriteLine("****对文件夹'" + name + "'进行杀毒");  //模拟杀毒  
          
        //如果是Folder类型的成员，递归调用Folder的killVirus()方法  
        foreach(Object obj in folderList) {  
            ((Folder)obj).killVirus();  
        }  
          
        //如果是ImageFile类型的成员，调用ImageFile的killVirus()方法  
        foreach(Object obj in imageList) {  
            ((ImageFile)obj).killVirus();  
        }  
          
        //如果是TextFile类型的成员，调用TextFile的killVirus()方法  
        foreach(Object obj in textList) {  
            ((TextFile)obj).killVirus();  
        }  
    }   
    }

调用方法

            Folder folder1, folder2, folder3;
            folder1 = new Folder("Sunny的资料");
            folder2 = new Folder("图像文件");
            folder3 = new Folder("文本文件");

            ImageFile image1, image2;
            image1 = new ImageFile("小龙女.jpg");
            image2 = new ImageFile("张无忌.gif");

            TextFile text1, text2;
            text1 = new TextFile("九阴真经.txt");
            text2 = new TextFile("葵花宝典.doc");

            folder2.addImageFile(image1);
            folder2.addImageFile(image2);
            folder3.addTextFile(text1);
            folder3.addTextFile(text2);
            folder1.addFolder(folder2);
            folder1.addFolder(folder3);

            folder1.killVirus();
            Console.Read();

对文件夹的病毒查杀也就这样完成了，但是现在看起来，文件夹类中的东西太多，对每一个类型的文件都有增，删，查，代码太过冗余。

系统没有提供抽象层，文件类和文件夹类需要当做两个对象对待。

灵活性太差，当需要增加或者改变文件类时需要大动干戈。

这时便能用上组合模式了！

组合模式的主要作用是将父节点和叶子节点当做同一种类型对待，将两者抽象出一种类，这样使用两者就有了一致性。

      在组合模式结构图中包含如下几个角色：

      ● Component（抽象构件）：

        为组合中的对象声明接口。

        在适当的情况下，实现所有类共有接口的缺省行为。

声明一个接口用于访问和管理Component的子组件。

（可选）在递归结构中定义一个接口，用于访问一个父部件，并在一个合适的情况下实现它。

      ● Leaf（叶子构件）：它在组合结构中表示叶子节点对象，叶子节点没有子节点，它实现了在抽象构件中定义的行为。对于那些访问及管理子构件的方法，可以通过异常等方式进行处理。

      ● Composite（容器构件）：它在组合结构中表示容器节点对象，容器节点包含子节点，其子节点可以是叶子节点，也可以是容器节点，它提供一个集合用于存储子节点，实现了在抽象构件中定义的行为，包括那些访问及管理子构件的方法，在其业务方法中可以递归调用其子节点的业务方法。

      组合模式的关键是定义了一个抽象构件类，它既可以代表叶子，又可以代表容器，而客户端针对该抽象构件类进行编程，无须知道它到底表示的是叶子还是容器，可以对其进行统一处理。同时容器对象与抽象构件类之间还建立一个聚合关联关系，在容器对象中既可以包含叶子，也可以包含容器，以此实现递归组合，形成一个树形结构。

抽象出的类：

 abstract class Component
    {
        public abstract void add(Component c); //增加成员  
        public abstract void remove(Component c); //删除成员  
        public abstract Component getChild(int i); //获取成员  
        public abstract void operation();  //业务方法 
    }

文本类

class TextFile:Component
    {
        private String name;

        public TextFile(String name)
        {  
          this.name = name;  
        }
        public override void add(Component c)
        {
            Console.WriteLine("对不起，不支持该方法！"); 
        }
        public override void remove(Component c)
        {
            Console.WriteLine("对不起，不支持该方法！"); 
        }
        public override Component getChild(int i)
        {
            return null;
        }
        public override void operation()
        {
            Console.WriteLine("----对文本文件'" + name + "'进行杀毒"); 
        }
    }

图片类

 private String name;
        public ImageFile(String name)
        {  
          this.name = name;  
        }
        public override void add(Component c)
        { 
        Console.WriteLine("对不起，不支持该方法！");  
        }
        public override void remove(Component c)
        {
            Console.WriteLine("对不起，不支持该方法！"); 
        }
        public override Component getChild(int i)
        {
            return null;
        }
        public override void operation()
        { 
         Console.WriteLine("----对图片文件'" + name + "'进行杀毒");  
        }

文件夹类

class Folder:Component
    {
        private List<Component> list = new List<Component>();

        private String name;

        public Folder(String name)
        {
            this.name = name;
        }  
        public override  void add(Component c)
        {
            list.Add(c);
        }
        public override void remove(Component c)
        {
            list.Remove(c);
        }
        public override Component getChild(int i)
        {
            return (Component)list[i];  
        }
        public override void operation()
        {
         Console.WriteLine("****对文件夹'" + name + "'进行杀毒");  //模拟杀毒  
          
        //递归调用成员构件的killVirus()方法  
         foreach (Object obj in list)
         {
             ((Component)obj).operation();  
         }  
        }
    }

测试

   //针对抽象构件编程  
            Component file1, file2, file3, file4, file5, folder1, folder2, folder3, folder4;

            folder1 = new Folder("Sunny的资料");
            folder2 = new Folder("图像文件");
            folder3 = new Folder("文本文件"); 8 
            file1 = new ImageFile("小龙女.jpg");
            file2 = new ImageFile("张无忌.gif");
            file3 = new TextFile("九阴真经.txt");
            file4 = new TextFile("葵花宝典.doc");

            folder2.add(file1);
            folder2.add(file2);
            folder3.add(file3);
            folder3.add(file4);
            folder1.add(folder2);
            folder1.add(folder3);
            folder1.add(folder4);

            //从“Sunny的资料”节点开始进行杀毒操作  
            folder1.operation();
            Console.ReadLine();

组合模式又分为透明组合模式与安全组合模式。

上述的组合模式为透明组合。将子节点与父节点的功能全部放入一个抽象类中，如果有一方（子节点或父节点）没有此功能，则使用错误处理代码。

安全组合模式则是将父节点与子节点的相同类抽象出来，而每个对象的特殊类在各自现实类中完成。

安全组合模式：

将相同功能抽象出来

abstract class AbstractFile {  
    public abstract void operation();
}

具体实现片段

    AbstractFile file1,file2,file3,file4,file5;  
    Folder folder1,folder2,folder3,folder4; //不能透明处理容器构件  
        //其他代码省略  

还是比较考虑优先使用透明组合安全模式。应为这样抽象的程度加大，便于后期维护。

学习于   https://www.cnblogs.com/lfxiao/p/6816026.html