『设计模式』 又谈麦当劳的食品--组合模式(Composite)

//抽象节点类
    abstract class Component
    {
        protected string name;
public Component(string name)
        {
            this.name = name;
        }
        public abstract void Add(Component c);
        public abstract void Remove(Component c);
        public abstract void Display(int depth);
    }
    //叶子节点类
    class Leaf:Component
    {
        public Leaf(string name) : base(name) { }
        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);
        }
    }
    //组合类
    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 Display(int depth)
        {
            Console.WriteLine(new String('-', depth) + name);
            foreach(Component component in children)
            {
                component.Display(depth + 2);
            }
        }
        public override void Remove(Component c)
        {
            children.Remove(c);
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            Composite root = new Composite("root");
            root.Add(new Leaf("LeafA"));
            root.Add(new Leaf("LeafB"));
            Composite comp = new Composite("CompositeX");
            comp.Add(new Leaf("LeafXA"));
            comp.Add(new Leaf("LeafXB"));
            root.Add(comp);
            Composite comp2 = new Composite("CompositeXY");
            comp2.Add(new Leaf("LeafXYA"));
            comp2.Add(new Leaf("LeafXYB"));
            comp.Add(comp2);
            root.Add(new Leaf("LeafC"));
            Leaf leaf = new Leaf("LeafD");
            root.Add(leaf);
            root.Remove(leaf);
            root.Display(1);
            Console.Read();
        }
    }
认识组合模式

 组合模式的目的

让客户端不再区分操作的是组合对象还是叶子对象，而是以一种统一的方式来操作对象树

组合模式会组合出树形结构来，这也就意味着,所有可以使用对象树来描述或操作的功能，都可以考虑使用组合模式。比如读取XML文件，或是对语句进行语法分析等。组合模式的实现根据所实现接口的区别分为两种形式，分别称为安全模式和透明模式。组合模式可以不提供父对象的管理方法，但组合模式必须在合适的地方提供子对象的管理方法(诸如Fadd、remove、Display等)。
透明方式

 在Component里面声明所有的用来管理子类对象的方法，包括add ()、remove ()，以及Display ()方法。优点:所有的构件类都有相同的接口。在客户端看来，树叶类对象与组合类对象的区别起码在接口层次上消失了，客户端可以同等的对待所有的对象。这就是透明形式的组合模式。缺点:不够安全，因为树叶类对象和合成类对象在本质上是有区别的。树叶类对象不可能有下平个层次的对象,因此add()、remove(）以及Display ()方法没有意义，在编译时期不会出错，而会在运行时期才会出错。
安全方式

 在Composite类里面声明所有的用来管理子类对象的方法优点:这样的做法是安全的做法，树叶类型的对象根本就没有管理子类对象的方法,因此，如果客户端对树叶类对象使用这些方法时，程序会在编译时期出错。缺点:不够透明，树叶类和合成类将具有不同的接口
使用情况

 需求中是体现部分与整体层次的结构时希望用户忽略组合对象与单个对象的不同,统一的使用组合结构中的所有对象时。
优点

 定义了包含基本对象和组合对象的类层次结构

基本对象可以组合成组合对象，组合对象又能组合成更复杂的组合对象，可以不断地递归组合下去,从而构成一个统一的组合对象的类层次结构统一了组合对象和叶子对象简化了客户端调用

不用区分组合对象和叶子对象更容易扩展

由于客户端是统一的面对Component来操作，因此,新定义的Composite或leaf子类能够很容易的与已有的结构一起工作，而不需改变客户端
缺点
很难限制组合中的组件类型

这是容易添加新的组件带来的问题，在需要检测组件类型的时候，使得我们不能依靠编译期的类型约束来完成，必须在运行期间动态检测
本质
同意叶子对象和组合对象
实例

package 组合模式;

abstract public class Node {
	protected   String Node_Name;

	public Node(String node_Name) {

		Node_Name = node_Name;
	}
	abstract public void  add_Node(Node node);
	abstract public void  remove_Node(Node node);
	abstract public void  show();
}

package 组合模式;

public class Leaf_Node extends Node{

	
	public Leaf_Node(String node_Name) {
		super(node_Name);
 
	}
	@Override
	public void add_Node(Node node) {
		// TODO Auto-generated method stub
		System.out.println("Warning:此食物已经为最细化分类，不能进一步分类");
	}
	@Override
	public void remove_Node(Node node) {
		// TODO Auto-generated method stub
		System.out.println("Warning:此食物已经为最细化分类，无子分类"); //暗示伍兹不行？玩梗！
	}
	@Override
	public void show() {
		System.out.println("  "+Node_Name);
	}
}

package 组合模式;

import java.util.ArrayList;
import java.util.List;

public class Branch_Node extends Node {
	List<Node> Node_List=new ArrayList<Node>();
	public Branch_Node(String node_Name) {
		super(node_Name);
	}

	@Override
	public void add_Node(Node node) {
		Node_List.add(node);
	}

	@Override
	public void remove_Node(Node node) {
		Node_List.remove(node);
	}

	@Override
	public void show() {
		 System.out.println("+"+Node_Name);
		 for(Node node:Node_List)
		 {
			 System.out.print("  ");
			 node.show();
		 }
	}
 
}

package 组合模式;

public class Client {
	public static void main(String[] args) {
		Node Main_Food=new Branch_Node("主食");
		Node Hamburger=new Branch_Node("汉堡");
		Node Sandwich=new Branch_Node("三明治");
		Node JTHB=new Leaf_Node("鸡腿堡");
		Node NRHB=new Leaf_Node("牛肉堡");
		Node HYSMZ=new Leaf_Node("黄油三明治");
		Node TLSMZ=new Leaf_Node("甜辣三明治");
		Sandwich.add_Node(HYSMZ);
		Sandwich.add_Node(TLSMZ);
		Hamburger.add_Node(JTHB);
		Hamburger.add_Node(NRHB);
		Main_Food.add_Node(Sandwich);
		Main_Food.add_Node(Hamburger);
		Main_Food.show();
	}
}