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

23 种设计模式+额外常用设计模式汇总 (持续更新）
我又又又谈了一期麦当劳，麦当劳看到了记得打钱 😂

引入

• 商品类别树的节点被分成两种，一种是容器节点,另一种是叶子节点。
• 容器节点可以包含其他容器节点或者叶子节点

组合模式

• 组合模式有时又叫做部分——整体模式(Part-Whole)
  。组合模式将对象组织到树结构中，可以用来描述整体与部分的关系。组合模式可以使客户端将单纯元素与复合元素同等看待。
• 一个树结构由两种节点组成:树枝节点和树叶节点。树枝节点可以有子节点，而一个树叶节点不可以有子节点。除了根节点外，其它节点有且只有一个父节点。

模式结构

• 抽象构件(Component)角色
  这是一个抽象角色，它给参与组合的对象规定一个接口。这个角色给出共有接口及其默认行为。
• 树叶构件(Leaf) 角色
  代表参加组合的树叶对象。一个树叶对象没有下级子对象。
• 树枝构件(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子类能够很容易的与已有的结构一起工作，而不需改变客户端

缺点
很难限制组合中的组件类型

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

麦当劳的食物的例子：
graph LR
A((主食)) --> B((汉堡))
A --> C((三明治))
B --> D{鸡腿堡}
B-->E{牛肉堡}
C --> F{黄油三明治}
C --> G{甜辣三明治}


其中圆形为枝节点
菱形为叶节点

抽象节点
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();
	}
}