`
TRAMP_ZZY
  • 浏览: 139875 次
社区版块
存档分类
最新评论

设计模式-组合模式

    博客分类:
  • Java
阅读更多

当有数个对象的集合,它们彼此之间有“整体/部分”的关系,并且你想用一致的方法对待这些对象,就需要用到组合模式。

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 getDescription() {
		throw new UnsupportedOperationException();
	}
	
	public double getPrice() {
		throw new UnsupportedOperationException();
	}
	
	public boolean isVegetarian() {
		throw new UnsupportedOperationException();
	}
	
	public void print() {
		throw new UnsupportedOperationException();
	}
	
	abstract Iterator createIterator();
}

public class Menu extends MenuComponent {

	ArrayList menuComponents = new ArrayList();
	String name;
	String description;
	
	public Menu(String name, String description) {
		super();
		this.name = name;
		this.description = description;
	}
	
	@Override
	public void add(MenuComponent component) {
		menuComponents.add(component);
	}
	
	@Override
	public void remove(MenuComponent component) {
		menuComponents.remove(component);
	}
	
	@Override
	public MenuComponent getChild(int i) {
		return (MenuComponent) menuComponents.get(i);
	}
	
	@Override
	public String getName() {
		return name;
	}
	
	@Override
	public String getDescription() {
		return description;
	}
	
	@Override
	public void print() {
		System.out.print("\n" + getName());
		System.out.println(", " + getDescription());
		System.out.println("-----------------------");
		
		Iterator iterator = menuComponents.iterator();
		while (iterator.hasNext()) {
			MenuComponent component = (MenuComponent) iterator.next();
			component.print();
		}
	}

	@Override
	Iterator createIterator() {
		return new CompositeIterator(menuComponents.iterator());
	}
}

public class MenuItem extends MenuComponent {
	String name;
	String description;
	boolean vegetarian;
	double price;
	
	public MenuItem(String name, String description, boolean vegetarian,
			double price) {
		super();
		this.name = name;
		this.description = description;
		this.vegetarian = vegetarian;
		this.price = price;
	}
	
	@Override
	public String getName() {
		return name;
	}
	
	@Override
	public String getDescription() {
		return description;
	}
	
	@Override
	public double getPrice() {
		return price;
	}
	
	@Override
	public boolean isVegetarian() {
		return vegetarian;
	}
	
	public void print() {
		System.out.print(" " + getName());
		if (isVegetarian()) {
			System.out.println("(v)");
		}
		System.out.println(", " + getPrice());
		System.out.println("   --" + getDescription());
	}

	@Override
	Iterator createIterator() {
		return new NullIterator();
	}
}

public class CompositeIterator implements Iterator {

	Stack<Iterator> stack = new Stack<Iterator>();
	
	public CompositeIterator(Iterator iterator) {
		stack.add(iterator);
	}
	
	@Override
	public boolean hasNext() {
		if (stack.empty()) {
			return false;
		} else {
			Iterator iterator = stack.peek();
			if (!iterator.hasNext()) {
				stack.pop();
				return hasNext();
			} else 
				return true;
		}
	}

	@Override
	public Object next() {
		if (hasNext()) {
			Iterator iterator = stack.peek();
			MenuComponent component = (MenuComponent) iterator.next();
			if (component instanceof Menu) {
				stack.push(component.createIterator());
			}
			return component;
		} else 
			return null;
	}

	@Override
	public void remove() {
		throw new UnsupportedOperationException();
	}

}

public class NullIterator implements Iterator {

	@Override
	public boolean hasNext() {
		return false;
	}

	@Override
	public Object next() {
		return null;
	}

	@Override
	public void remove() {
		throw new UnsupportedOperationException();
	}

}

public class Waitress {

	MenuComponent allMenus;
	
	public Waitress(MenuComponent allMenus) {
		this.allMenus = allMenus;
	}
	
	public void printMenu() {
		this.allMenus.print();
	}
	
	public void printVegetarianMenu() {
		Iterator iterator = allMenus.createIterator();
		
		while (iterator.hasNext()) {
			MenuComponent component = (MenuComponent) iterator.next();
			try {
				if (component.isVegetarian()) {
					component.print();
				}
			} catch (UnsupportedOperationException e) {
				e.printStackTrace();
			}
		}
	}
}

public class MenuTestDrive {

	public static void main(String[] args) {

		MenuComponent pancakeHouseMenu = 
				new Menu("PANCAKE HOUSE MENU", "Breakfase");
		MenuComponent dinerMenu = 
				new Menu("DINER MENU", "Lunch");
		MenuComponent cafeMenu = 
				new Menu("CAFE", "Dinner");
		MenuComponent dessertMenu = 
				new Menu("DESSERT MENU", "Dessert of course!");
		
		MenuComponent allMenus = 
				new Menu("ALL MENUS" , "ALL menus combined");
		
		allMenus.add(pancakeHouseMenu);
		allMenus.add(dinerMenu);
		allMenus.add(cafeMenu);
		
		dinerMenu.add(new MenuItem("Pasta", "Spaghetti with Marinara Sauce", true, 3.89));
		dinerMenu.add(dessertMenu);
		dessertMenu.add(new MenuItem("Apple Pie", "Apple pie with a flakey crust", true, 1.99));
		
		Waitress waitress = new Waitress(allMenus);
		waitress.printMenu();
		
	}

}
分享到:
评论

相关推荐

    java常用设计模式-组合模式

    java常用设计模式-组合模式 组合模式(Composite Pattern)是一种结构型设计模式,它允许你将对象组合成树形结构以表示“部分-整体”的层次结构。这种模式使得客户端可以统一对待单个对象和对象组合。在组合模式中...

    设计模式-组合模式-示例代码

    设计模式中的组合模式的示例代码。 包括透明写法和安全写法两种实现方式的示例。

    c++设计模式-结构型模式-组合模式

    c++设计模式-结构型模式-组合模式;qt工程;c++简单源码; 组合(Composite Pattern)模式的定义:有时又叫作整体-部分(Part-Whole)模式,它是一种将对象组合成树状的层次结构的模式,用来表示“整体-部分”的关系...

    设计模式-组合模式(讲解及其实现代码)

    组合模式是一种结构型设计模式,它允许我们使用树形结构来表示部分与整体的关系,使得我们能够以统一的方式来处理单个对象和对象的组合。在组合模式中,单个对象和组合对象都被视为同一类型,这使得客户端代码可以对...

    JAVA-设计模式-结构型模式-组合模式

    JAVA-设计模式-结构型模式-组合模式

    java设计模式-组合模式

    设计模式(Design pattern)代表了最佳的实践,通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段...

    C++设计模式--基于Qt4开源跨平台开发框架

    《C++设计模式--基于Qt4开源跨平台开发框架》一书主要探讨了如何在C++编程中利用设计模式,并结合Qt4框架进行高效的跨平台应用开发。设计模式是软件工程中的重要概念,它们是经过时间和实践验证的解决特定问题的模板...

    设计模式-组合实体

    在众多设计模式中,组合实体(Composite)模式是一种结构型模式,它允许我们以树形结构来表示部分与整体的关系,使得用户可以一致地处理单个对象和对象组合。在iOS开发中,组合实体模式尤其有用,因为它简化了复杂...

    设计模式--组合模式java例子

    组合模式是一种结构型设计模式,它允许我们使用树形结构来表示部分-整体关系,使得我们能够像处理单个对象一样处理整个集合。在Java中,这种模式的应用可以帮助我们简化对复杂对象层次结构的操作,同时保持接口的...

    设计模式-Java语言中的应用

    设计模式通常分为三类:创建型模式(如工厂模式、抽象工厂模式、单例模式、建造者模式、原型模式),结构型模式(如适配器模式、装饰器模式、代理模式、桥接模式、组合模式、外观模式、享元模式)以及行为型模式(如...

    C++设计模式-基于QT4开源跨平台开发框架 源码

    C++设计模式是一种在软件开发中经过验证的解决常见问题的方法论,它为软件开发提供了标准的解决...在研究提供的源码时,读者应重点关注如何在实际场景中应用和组合这些设计模式,以及它们如何与QT4框架的特性相结合。

    java设计模式---诙谐易懂版

    根据给定文件内容,以下是关于Java设计模式的知识点说明: 1. 策略模式(Strategy Pattern)是一种行为设计模式,允许在运行时选择算法的行为。策略模式的意图是定义一系列算法,将每个算法封装起来,并使它们可以...

    设计模式精解-GoF-23种设计模式解析--附C++源代码

    - 组合模式(Composite):将对象组合成树形结构以表示“部分-整体”的层次结构。 - 装饰模式(Decorator):动态地给一个对象添加一些额外的职责。 - 享元模式(Flyweight):使用共享对象,有效地支持大量细...

    组合模式-空军指挥系统.zip

    总结来说,"组合模式-空军指挥系统"这一主题涉及到Java设计模式中的组合模式理论和实践,以及如何在实际的空军指挥系统项目中应用该模式。通过组合模式,我们可以构建出层次分明、易于管理和扩展的系统,使得在复杂...

    Java设计模式----通俗易懂版

    这个资源"Java设计模式----通俗易懂版"显然是一个专门针对初学者或需要深入理解设计模式的开发者编写的指南。作者以形象生动的例子解释了23种经典的Java设计模式,使得复杂的概念变得更加易于理解。 首先,我们要...

    设计模式课件大全

    设计模式06-适配器、桥接、组合模式 设计模式07-组合模式、装饰模式 设计模式09-外观模式、享元模式 设计模式10-代理模式、结构型模式大复习 设计模式11-行为模式-责任链、命令模式 设计模式12-解释器模式 设计模式...

    软件设计模式--填空题+简答题(复习7).rar

    2. **设计模式分类**:设计模式通常分为三类:创建型模式(如工厂方法、抽象工厂、单例、建造者、原型)、结构型模式(如适配器、桥接、装饰、组合、代理、外观、享元)和行为型模式(如责任链、命令、解释器、迭代...

    设计模式实验报告-组合模式.docx

    ### 设计模式实验报告——组合模式 #### 实验目的与背景 本次实验旨在通过实践学习设计模式中的组合模式,理解其工作原理及应用场景。组合模式(Composite Pattern)是一种结构型设计模式,它允许用户将对象组合成...

    JAVA设计模式-chm版

    这个“JAVA设计模式-chm版”资源显然包含了关于Java设计模式的详细信息,便于理解和应用。设计模式是对常见问题的解决方案的标准化描述,它们在软件工程中起到了重要的作用,帮助开发者创建可维护、可扩展且易于理解...

Global site tag (gtag.js) - Google Analytics