设计模式——11 组合模式

11 CompositePattern(组合模式)

         前言:帮助客户用同样的方法遍历不同的集合。

需求:

         上次Vander在Panda的帮助下,很好地解决了厨师们的菜单使用不同的集合,解决了不同集合的遍历问题,但是市场竞争真的太激烈了,Vande在九方购物广场的Vander奶茶店也迎来了经营问题,所以现在需要将奶茶店的菜单加入到烧烤菜单中,但是添加会有什么问题呢。我们来看看现在的结构:

 很明显,类型不匹配,无法直接将奶茶菜单加入到Barbecue的子菜单中,别无它法,只能请所有的厨师重新设计他们的菜单,来到这里很容易就会想到树形结构,需要这种树形结构能够容纳菜单、子菜单和菜单项,并且需要能够在每个菜单的各项间游走,需要遍历整个菜单,包括子菜单也要遍历。形成的树如下所示:

 

         正当Vander毫无头绪,不知道这个代码要怎么写的时候,Panda大师又来了,这个可以用“组合模式”解决,下面由我Panda来说明一下组合模式。

组合模式:允许你将对象组合成树形结构来变现“整体/部分”层次结构,组合能让客户以一致的方式处理个别对象以及对象组合。一旦有了丰富的大菜单,我们就可以使用这个模式来“统一处理个别对象和组合对象”。意味着有一个树形结构的菜单(Menu)、子菜单和可能还带有菜单项的子菜单,任何一个菜单都是一种“组合”,因为它既可以包括其他菜单,也可以包括菜单项(MenuItem)。个别对象只是菜单项——并未持有其他对象。菜单就是“节点”,而菜单项就是“叶子节点”。

         组合模式让我们能用树形方式创建对象的结构,树里面包含了组合以及个别的对象,使用组合结构,我们能把相同的操作应用在组合和个别对象上。换句话说,就是在大多数情况下,我们可以忽略对象组合和个别对象之间的差别。用一个浅显一点的例子把:就是一个print语句,可以print(叶子节点)、print(根)、print(子菜单)、print(菜单),就是说可以忽略它在树里面的位置。

         说了那么多,Vander还是懵逼的,接着Panda继续讲解一下组合模式的一般套路,如下图:

         解释一下以上的图,叶子跟组合都是继承于组件,客户端代码主要是跟组件打交道,叶子就是菜单中的每个菜单项,组合指的就是菜单(BarbecueMenu、PizzaMenu等)。使用组合迭代器,就是为了可以在遍历的时候忽略它是菜单还是菜单项,也就是说不管是叶子还是组合对客户端代码来说都是透明的。

这么说可能有点抽象,直接使用吧,用组合模式来重新写菜单:

 

这种方式比较简单,相当于Menu跟MenuItem将迭代器实现转移到了内部,也就是说遍历什么的操作都在Menu跟MenuItem自身来完成。

Menu

public class Menu extends MenuComponent {

	ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
	
	private String name;
	
	private String desc;

	public Menu(String name, String desc) {
		this.name = name;
		this.desc = desc;
	}
	
	public void add(MenuComponent menuComponent) {
		menuComponents.add(menuComponent);
	}
	
	public void remove(MenuComponent menuComponent) {
		menuComponents.remove(menuComponent);
	}
	
	public MenuComponent getChild(int i) {
		return menuComponents.get(i);
	}

	public String getName() {
		return name;
	}

	public String getDesc() {
		return desc;
	}

	public void print() {
		System.out.println("\nname:" + getName() + "#desc:" + getDesc());
		System.out.println("----------------------------------------");
		Iterator<MenuComponent> iterator = menuComponents.iterator();
		while(iterator.hasNext()) {
			MenuComponent menuComponent = iterator.next();
			menuComponent.print();
		}
	}
	
}

 MenuItem

public class MenuItem extends MenuComponent {

	private String name;
	
	private String desc;
	
	private double price;

	public MenuItem(String name, String desc, double price) {
		super();
		this.name = name;
		this.desc = desc;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public String getDesc() {
		return desc;
	}

	public double getPrice() {
		return price;
	}
	
	public void print() {
		System.out.println("name:" + getName() + "#desc:" + getDesc() + "#price:" + getPrice());
	}

}

 MenuComponent

public abstract class MenuComponent {

	public void add(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	
	public void remove(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	
	public MenuComponent getChild(int i) {
		throw new UnsupportedOperationException();
	}
	
	public String getName() {
		throw new UnsupportedOperationException();
	}
	
	public String getDesc() {
		throw new UnsupportedOperationException();
	}
	
	public double getPrice() {
		throw new UnsupportedOperationException();
	}
	
	public void print() {
		throw new UnsupportedOperationException();
	}
	
}

 MenuAdmin

public class MenuAdmin {

	private MenuComponent menuComponent;

	public MenuAdmin(MenuComponent menuComponent) {
		super();
		this.menuComponent = menuComponent;
	}

	public void print() {
		menuComponent.print();
	}
	
}

 Main

public class Main {

	public static void main(String args[]) {
		
		Menu totalMenu = new Menu("TotalMenu", "TotalMenu");
		
		Menu pizzaMenu = new Menu("PizzaMenu", "PizzaMenu");
		Menu barbecueMenu = new Menu("barbecueMenu", "barbecueMenu");
		Menu milkTeaMenu = new Menu("milkTeaMenu", "milkTeaMenu");
		Menu hotPotMenu = new Menu("hotPotMenu", "hotPotMenu");
		
		pizzaMenu.add(new MenuItem("FruitPizza", "Hawaii Style", 38.0));
		pizzaMenu.add(new MenuItem("BuffPizza", "American Style", 28.0));
		pizzaMenu.add(new MenuItem("TunaPizza", "Japan Style", 18.0));
		
		milkTeaMenu.add(new MenuItem("Bubble milk tea", "big cup", 10.0));
		milkTeaMenu.add(new MenuItem("Coconut milk tea", "middle cup", 8.0));
		milkTeaMenu.add(new MenuItem("cheese tea", "middle cup", 18.0));
		
		hotPotMenu.add(new MenuItem("chicken", "with solt", 10));
		hotPotMenu.add(new MenuItem("tofu", "with solt", 5));
		hotPotMenu.add(new MenuItem("lettuce", "with solt", 10));
		
		barbecueMenu.add(new MenuItem("corn", "with pepper", 10));
		barbecueMenu.add(new MenuItem("chicken", "with pepper", 10));
		barbecueMenu.add(new MenuItem("fragrant-flowered garlic", "with pepper", 10));
		barbecueMenu.add(milkTeaMenu);

		totalMenu.add(hotPotMenu);
		totalMenu.add(barbecueMenu);
		totalMenu.add(pizzaMenu);
		totalMenu.print();
		
	}
	
}

 MenuComponent

public abstract class MenuComponent {

	public void add(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	
	public void remove(MenuComponent menuComponent) {
		throw new UnsupportedOperationException();
	}
	
	public MenuComponent getChild(int i) {
		throw new UnsupportedOperationException();
	}
	
	public String getName() {
		throw new UnsupportedOperationException();
	}
	
	public String getDesc() {
		throw new UnsupportedOperationException();
	}
	
	public double getPrice() {
		throw new UnsupportedOperationException();
	}
	
	public void print() {
		throw new UnsupportedOperationException();
	}
	
}

 实现效果:

 

第一种方式是不是违反了单一责任原则,想想看Menu里面是不是使用了迭代器来进行菜单的遍历操作,第一种方式用单一责任原则来换取了透明性(通过让组件的接口同时包含一些管理子节点和叶节点的操作,客户可以将组合和叶节点一视同仁。)

接下来,继续说第二种方式。第二种方式是把遍历的操作实现到了外部,也就是用外部迭代器来完成,我们先来看看图:

这个是当前菜单的树状图,有点复杂,我们简化一下,假设主菜单就只有一个BarbecueMenu:

 下面我们用图示的方法,大概画一下整个遍历的过程:

 

         相当于将BarbecueMenuIterator(普通的list迭代器),遍历到MilkteaMenu的时候,这个时候调用next()获取到的就是MilkteaMenu这个组合,然后由于它里面还有很多叶子,所以将这个组合放入堆栈中,再次next的时候,获取到这个组合迭代器的普通迭代器,再继续遍历,最后这个遍历完了,就将MenuteaMenuIterator从堆栈中移除,然后MilkteaCompositeIterator也移出,然后发现BarbecueMenuIterator也遍历完了,也移除,最后整个堆栈就空了,就算遍历完毕了,这里的位置信息不像之前的普通迭代器那样用pos来标记了,这里直接用栈来实现位置信息的存储。

下面我们上代码:(代码看上去不多,但是确实不好理解,请仔细体会递归的味道)

MenuComponent:(与第一种方式一致)

public class MenuItem extends MenuComponent {

	private String name;
	
	private String desc;
	
	private double price;

	public MenuItem(String name, String desc, double price) {
		super();
		this.name = name;
		this.desc = desc;
		this.price = price;
	}

	public String getName() {
		return name;
	}

	public String getDesc() {
		return desc;
	}

	public double getPrice() {
		return price;
	}
	
	public void print() {
		System.out.println("name:" + getName() + "#desc:" + getDesc() + "#price:" + getPrice());
	}

	@Override
	public Iterator<MenuComponent> createIteractor() {
		return new NullIterator();
	}

}

Menu

public class Menu extends MenuComponent {

	ArrayList<MenuComponent> menuComponents = new ArrayList<MenuComponent>();
	
	private String name;
	
	private String desc;

	public Menu(String name, String desc) {
		this.name = name;
		this.desc = desc;
	}
	
	public void add(MenuComponent menuComponent) {
		menuComponents.add(menuComponent);
	}
	
	public void remove(MenuComponent menuComponent) {
		menuComponents.remove(menuComponent);
	}
	
	public MenuComponent getChild(int i) {
		return menuComponents.get(i);
	}

	public String getName() {
		return name;
	}

	public String getDesc() {
		return desc;
	}

	public void print() {
		System.out.println("name:" + getName() + "#desc:" + getDesc());
	}
	
	@Override
	public Iterator<MenuComponent> createIteractor() {
		return new CompositeIterator(menuComponents.iterator());
	}
	
}

 NullIterator

public class NullIterator implements Iterator<MenuComponent> {

	public boolean hasNext() {
		return false;
	}

	public MenuComponent next() {
		return null;
	}

}

 ComponentIterator:(重中之中)

public class CompositeIterator implements Iterator<MenuComponent> {

	private Stack<Iterator<MenuComponent>> stack = new Stack<Iterator<MenuComponent>>();
	
	public CompositeIterator(Iterator<MenuComponent> iterator) {
		stack.push(iterator);
	}

	public boolean hasNext() {
		if(stack.empty()) {
			return false;
		} else {
			Iterator<MenuComponent> iterator = stack.peek();
			if(!iterator.hasNext()) {
				stack.pop();
				return hasNext();
			} else {
				return true;
			}
		}
	}

	public MenuComponent next() {
		if(hasNext()) {
			Iterator<MenuComponent> itemIterator = stack.peek();
			MenuComponent component = itemIterator.next();
			if(component instanceof Menu) {
				stack.push(component.createIteractor());
			}
			return component;
		}
		return null;
	}

}

 MenuAdmin

public class MenuAdmin {

	private MenuComponent menuComponent;

	public MenuAdmin(MenuComponent menuComponent) {
		super();
		this.menuComponent = menuComponent;
	}

	public void print() {
		Iterator<MenuComponent> iterator =menuComponent.createIteractor();
		while(iterator.hasNext()) {
			MenuComponent menuComponent = iterator.next();
			menuComponent.print();
		}
	}
	
}

 Main

public class Main {

	public static void main(String args[]) {
		
		Menu totalMenu = new Menu("TotalMenu", "TotalMenu");
		
		Menu pizzaMenu = new Menu("PizzaMenu", "PizzaMenu");
		Menu barbecueMenu = new Menu("barbecueMenu", "barbecueMenu");
		Menu milkTeaMenu = new Menu("milkTeaMenu", "milkTeaMenu");
		Menu hotPotMenu = new Menu("hotPotMenu", "hotPotMenu");
		
		pizzaMenu.add(new MenuItem("FruitPizza", "Hawaii Style", 38.0));
		pizzaMenu.add(new MenuItem("BuffPizza", "American Style", 28.0));
		pizzaMenu.add(new MenuItem("TunaPizza", "Japan Style", 18.0));
		
		milkTeaMenu.add(new MenuItem("Bubble milk tea", "big cup", 10.0));
		milkTeaMenu.add(new MenuItem("Coconut milk tea", "middle cup", 8.0));
		milkTeaMenu.add(new MenuItem("cheese tea", "middle cup", 18.0));
		
		hotPotMenu.add(new MenuItem("chicken", "with solt", 10));
		hotPotMenu.add(new MenuItem("tofu", "with solt", 5));
		hotPotMenu.add(new MenuItem("lettuce", "with solt", 10));
		
		barbecueMenu.add(new MenuItem("corn", "with pepper", 10));
		barbecueMenu.add(new MenuItem("chicken", "with pepper", 10));
		barbecueMenu.add(new MenuItem("fragrant-flowered garlic", "with pepper", 10));
		barbecueMenu.add(milkTeaMenu);

		totalMenu.add(hotPotMenu);
		totalMenu.add(barbecueMenu);
		totalMenu.add(pizzaMenu);
		
		MenuAdmin menuAdmin = new MenuAdmin(totalMenu);
		menuAdmin.print();
		
	}
	
}

 实现效果:

 

这里有个小细节说明一下,MenuItem使用了NullIterator,由于菜单项已经是子节点了,没有什么好遍历的了,这里如果不用NullIterator,也可以直接返回null,如果直接返回null的话,就需要加入条件判断。但是如果用了NullIterator,就相当于创建了一个没有作用的迭代器。这个迭代器的hasNext()永远都是false,这样操作起来更具有统一性。

         以上的代码最主要就是CompositeIterator的部分,需要自己好好理解一番。

下面我们先来总结一下我们学过的一些模式:

策略

封装可互换的行为,并使用委托决定用哪个行为。

适配器

改变一个或多个类的接口

迭代器

提供一个方式遍历集合,无需暴露集合的实现

外观

简化一群类的接口

组合

客户可以将对象的集合以及个别对象一视同仁

观察者

当某个状态发生变化的时候,允许一群对象被通知到。

 

最后又到了喜闻乐见的总结部分,我们又来总结我们现在现有的设计模式武器。

面向对象基础

         抽象、封装、多态、继承

八大设计原则

设计原则一:封装变化

设计原则二:针对接口编程,不针对实现编程。

         设计原则三:多用组合,少用继承。

         设计原则四:为交互对象之间的松耦合设计而努力

设计原则五:对扩展开放,对修改关闭

设计原则六:依赖抽象,不要依赖于具体的类

设计原则七:只和你的密友谈话

设计原则八:别找我,我有需要会找你

设计原则九:类应该只有一个改变的理由

模式

组合模式:允许你将对象组成树形结构来表现整体/部分的层次结构。组合能让客户以一致的方式处理个别对象和对象组合。

最后献上此次设计所涉及到的源码,有需要的小伙伴可以下载来运行一下,首先先自己进行设计,然后再参考,这样才能加深模式的理解。

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值