组合模式

最新推荐文章于 2024-04-23 19:31:35 发布
最新推荐文章于 2024-04-23 19:31:35 发布
阅读量354 收藏 3
点赞数
分类专栏： 设计模式 设计模式
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/79705777
版权

组合模式

组合模式主要表现形式为树型结构，有一个整体和部分的关系，如我们平时使用的省份，县市，区县等

下面我们来看一个例子

这是一家餐厅的菜单结构，现在我们需要将其遍历输出
这里写图片描述

引入组合模式设计
这里写图片描述

对应代码

基类代码

package headfirst.hd.composite.eg;

public abstract class Component {
	
	// 集合操作-增
	public void add(Component menuComponent) {
		throw new UnsupportedOperationException();
	}

	// 集合操作-删
	public void remove(Component menuComponent) {
		throw new UnsupportedOperationException();
	}

	// 集合操作-查
	public Component getChild(int i) {
		throw new UnsupportedOperationException();
	}

	public String getName() {
		throw new UnsupportedOperationException();
	}

	public float getPrice() {
		throw new UnsupportedOperationException();
	}
	
	public void print(int offset) {
		throw new UnsupportedOperationException();
	}
	
	//偏移量，补空格使用
	public void printOffsed(int offset) {
		StringBuffer blank = new StringBuffer("");
		for (int i = 0; i < offset; i++) {
			blank.append("     ");
		}
		System.out.print(blank);
	}
}

菜单项

package headfirst.hd.composite.eg;

//菜单项
public class Item extends Component {
	private String name;
	private float price;
	
	public Item(String name, float price) {
		this.name = name;
		this.price = price;
	}
	
	@Override
	public String getName() {
		return name;
	}
	
	@Override
	public float getPrice() {
		return price;
	}

	@Override
	public void print(int offset) {
		super.printOffsed(offset);
		System.out.println("[商品名=" + name + ", 价格=" + price + "]");
	}
}

组合菜单

package headfirst.hd.composite.eg;

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

//组合菜单
public class Menu extends Component {

	List<Component> menuComponents = new ArrayList<Component>();
	String name;
	String description;
	
	public Menu(String name, String description) {
		this.name = name;
		this.description = description;
	}
	@Override
	public void add(Component menuComponent) {
		menuComponents.add(menuComponent);
	}
	@Override
	public void remove(Component menuComponent) {
		menuComponents.remove(menuComponent);
	}
	@Override
	public Component getChild(int i) {
		return menuComponents.get(i);
	}
	
	@Override
	public String getName() {
		return name;
	}
	
	public String getDescription() {
		return description;
	}
	
	@Override
	public void print(int offset) {
		super.printOffsed(offset);
		System.out.println("{菜单名=" + name + ", 描述=" + description + "}");
		ListIterator<Component> listIterator = menuComponents.listIterator();
		while (listIterator.hasNext()) {
			Component itemComponent = (Component) listIterator.next();
			//递归思想
			itemComponent.print(offset+1);
		}
	}
	
}

服务员代码

package headfirst.hd.composite.eg;

public class Waitress {

	Component menu;

	public Waitress(Component menu) {
		this.menu = menu;
	}
	
	public void printMenu() {
		menu.print(0);  
	}
	
}

测试代码

package headfirst.hd.composite.eg;

public class DriveTest {

	public static void main(String[] args) {
		Component menu = simpleFactory();
		Waitress waitress = new Waitress(menu);
		//打印菜单
		waitress.printMenu();
	}

	//创建一份菜单
	private static Component simpleFactory() {
		//菜单
		Component menu = new Menu("菜单", "xxx饭店菜单");
		
		//菜单项
		Component menuA = new Menu("饭类", "类别：主食类");
		Component menuB = new Menu("水类", "类别：补充水分");
		Component menuC = new Menu("小吃类", "类别：零食");
		Component menuD = new Menu("汤类", "类别：水类的子类");
		menu.add(menuA);
		menu.add(menuB);
		menu.add(menuC);
		
		//菜单项中具体类别
		Component itemA1 = new Item("牛肉", 15f);
		Component itemA2 = new Item("鸡肉", 13f);
		Component itemA3 = new Item("鸭肉", 14f);
		menuA.add(itemA1);
		menuA.add(itemA2);
		menuA.add(itemA3);
		
		Component itemB1 = new Item("红茶", 4f);
		Component itemB2 = new Item("奶茶", 6f);
		menuB.add(itemB1);
		menuB.add(itemB2);
		menuB.add(menuD);	//菜单项的包含
		
		Component itemC1 = new Item("烤翅", 8f);
		Component itemC2 = new Item("尾虾", 8f);
		Component itemC3 = new Item("鱿鱼", 5f);
		menuC.add(itemC1);
		menuC.add(itemC2);
		menuC.add(itemC3);
		
		Component itemD1 = new Item("菜汤", 6f);
		Component itemD2 = new Item("酸汤", 6f);
		Component itemD3 = new Item("其他汤", 5f);
		menuD.add(itemD1);
		menuD.add(itemD2);
		menuD.add(itemD3);
		
		return menu;
	}

}

测试结果

{菜单名=菜单, 描述=xxx饭店菜单}
     {菜单名=饭类, 描述=类别：主食类}
          [商品名=牛肉, 价格=15.0]
          [商品名=鸡肉, 价格=13.0]
          [商品名=鸭肉, 价格=14.0]
     {菜单名=水类, 描述=类别：补充水分}
          [商品名=红茶, 价格=4.0]
          [商品名=奶茶, 价格=6.0]
          {菜单名=汤类, 描述=类别：水类的子类}
               [商品名=菜汤, 价格=6.0]
               [商品名=酸汤, 价格=6.0]
               [商品名=其他汤, 价格=5.0]
     {菜单名=小吃类, 描述=类别：零食}
          [商品名=烤翅, 价格=8.0]
          [商品名=尾虾, 价格=8.0]
          [商品名=鱿鱼, 价格=5.0]

输出流程为
这里写图片描述

引入迭代器模式，改造以上代码的输出，减少类的责任

主要目的：减少类拥有的责任，比如这里是菜单项要负责管理集合操作，那么我们将输出操作转移到其他类中，属于面向对象原则的单一原则

多个Iterator的整合应用参考：https://blog.csdn.net/dengjili/article/details/79720730

栈思想
这里写图片描述

对应代码

package headfirst.hd.composite.eg2;

import java.util.Iterator;

public abstract class Component{
	
	// 集合操作-增
	public void add(Component menuComponent) {
		throw new UnsupportedOperationException();
	}

	// 集合操作-删
	public void remove(Component menuComponent) {
		throw new UnsupportedOperationException();
	}

	// 集合操作-查
	public Component getChild(int i) {
		throw new UnsupportedOperationException();
	}

	public String getName() {
		throw new UnsupportedOperationException();
	}

	public float getPrice() {
		throw new UnsupportedOperationException();
	}
	
	public void print() {
		throw new UnsupportedOperationException();
	}
	
	//增加迭代器，用于遍历
	public Iterator<Component> createIterator() {
		throw new UnsupportedOperationException();
	}

}


package headfirst.hd.composite.eg2;

import java.util.Iterator;

//菜单项
public class Item extends Component {
	private String name;
	private float price;
	
	public Item(String name, float price) {
		this.name = name;
		this.price = price;
	}
	
	@Override
	public String getName() {
		return name;
	}
	
	@Override
	public float getPrice() {
		return price;
	}

	@Override
	public void print() {
		System.out.println("[商品名=" + name + ", 价格=" + price + "]");
	}

	@Override
	public Iterator<Component> createIterator() {
		return new NullIterator();
	}
	
}


package headfirst.hd.composite.eg2;

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

//组合菜单
public class Menu extends Component {

	List<Component> menuComponents = new ArrayList<Component>();
	String name;
	String description;
	
	public Menu(String name, String description) {
		this.name = name;
		this.description = description;
	}
	@Override
	public void add(Component menuComponent) {
		menuComponents.add(menuComponent);
	}
	@Override
	public void remove(Component menuComponent) {
		menuComponents.remove(menuComponent);
	}
	@Override
	public Component getChild(int i) {
		return menuComponents.get(i);
	}
	
	@Override
	public String getName() {
		return name;
	}
	
	public String getDescription() {
		return description;
	}
	
	@Override
	public void print() {
		System.out.println("{菜单名=" + name + ", 描述=" + description + "}");
	}
	
	//找出菜单项列表子类
	public Iterator<Component> Iterators() {
		return menuComponents.iterator();
	}
	
	@Override
	public Iterator<Component> createIterator() {
		return new CompositeIterator(this);
	}
	
}

核心输出管理器

package headfirst.hd.composite.eg2;

import java.util.Iterator;
import java.util.Stack;

public class CompositeIterator implements Iterator<Component> {

	Stack<Iterator<Component>> stack = new Stack<Iterator<Component>>();
	
	public CompositeIterator(Component menu) {
		stack.push(new IteratorAdapter(menu));
	}
	
	@Override
	public boolean hasNext() {
		
		//当前栈中没有迭代数据
		if (stack.isEmpty()) {
			return false;
		}
		
		//当前栈中有迭代数据
		Iterator<Component> iterator = stack.peek();
		//迭代数据中还有元素
		if (iterator.hasNext()) {
			return true;
		}
		
		//迭代数据中没有有元素，出栈
		stack.pop();
		return hasNext();
	}

	@Override
	public Component next() {
		//读取当前栈中的迭代器
		Iterator<Component> iterator = stack.peek();
		//取出元素
		Component component = iterator.next();
		//判断是菜单Menu类型
		if (Menu.class.isAssignableFrom(component.getClass())) {
			Menu menu = (Menu) component;
			stack.push(menu.Iterators());
		}
		
		return component;
	}

}

空迭代器

package headfirst.hd.composite.eg2;

import java.util.Iterator;

public class NullIterator implements Iterator<Component> {

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

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

}

首节点适配器

package headfirst.hd.composite.eg2;

import java.util.Iterator;

public class IteratorAdapter implements Iterator<Component> {

	private boolean isIterator = false;
	private Component componet = null;
	
	public IteratorAdapter(Component componet) {
		this.componet = componet;
		isIterator = false;
	}

	@Override
	public boolean hasNext() {
		return !isIterator;
	}

	@Override
	public Component next() {
		Component temp = componet;
		
		if (!isIterator) {
			isIterator = true;
			componet = null;
		}
		return temp;
	}

}

服务员代码

package headfirst.hd.composite.eg2;

import java.util.Iterator;

public class Waitress {

	Component menu;

	public Waitress(Component menu) {
		this.menu = menu;
	}
	
	public void printMenu() {
		Iterator<Component> iterator = menu.createIterator();
		
		while (iterator.hasNext()) {
			Component component = iterator.next();
			component.print();
		}
		
	}
	
}

测试类

package headfirst.hd.composite.eg2;

public class DriveTest {

	public static void main(String[] args) {
		Component menu = simpleFactory();
		
		Waitress waitress = new Waitress(menu);
		//打印菜单
		waitress.printMenu();
	}

	//创建一份菜单
	private static Component simpleFactory() {
		//菜单
		Component menu = new Menu("菜单", "xxx饭店菜单");
		
		//菜单项
		Component menuA = new Menu("饭类", "类别：主食类");
		Component menuB = new Menu("水类", "类别：补充水分");
		Component menuC = new Menu("小吃类", "类别：零食");
		Component menuD = new Menu("汤类", "类别：水类的子类");
		menu.add(menuA);
		menu.add(menuB);
		menu.add(menuC);
		
		//菜单项中具体类别
		Component itemA1 = new Item("牛肉", 15f);
		Component itemA2 = new Item("鸡肉", 13f);
		Component itemA3 = new Item("鸭肉", 14f);
		menuA.add(itemA1);
		menuA.add(itemA2);
		menuA.add(itemA3);
		
		Component itemB1 = new Item("红茶", 4f);
		Component itemB2 = new Item("奶茶", 6f);
		menuB.add(itemB1);
		menuB.add(itemB2);
		menuB.add(menuD);	//菜单项的包含
		
		Component itemC1 = new Item("烤翅", 8f);
		Component itemC2 = new Item("尾虾", 8f);
		Component itemC3 = new Item("鱿鱼", 5f);
		menuC.add(itemC1);
		menuC.add(itemC2);
		menuC.add(itemC3);
		
		Component itemD1 = new Item("菜汤", 6f);
		Component itemD2 = new Item("酸汤", 6f);
		Component itemD3 = new Item("其他汤", 5f);
		menuD.add(itemD1);
		menuD.add(itemD2);
		menuD.add(itemD3);
		
		return menu;
	}

}

测试结果

{菜单名=菜单, 描述=xxx饭店菜单}
{菜单名=饭类, 描述=类别：主食类}
[商品名=牛肉, 价格=15.0]
[商品名=鸡肉, 价格=13.0]
[商品名=鸭肉, 价格=14.0]
{菜单名=水类, 描述=类别：补充水分}
[商品名=红茶, 价格=4.0]
[商品名=奶茶, 价格=6.0]
{菜单名=汤类, 描述=类别：水类的子类}
[商品名=菜汤, 价格=6.0]
[商品名=酸汤, 价格=6.0]
[商品名=其他汤, 价格=5.0]
{菜单名=小吃类, 描述=类别：零食}
[商品名=烤翅, 价格=8.0]
[商品名=尾虾, 价格=8.0]
[商品名=鱿鱼, 价格=5.0]
采用访问者改造

完全解耦
https://blog.csdn.net/dengjili/article/details/83540512

dengjili
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
组合模式——透明组合模式，安全组合模式
qq_39368007的博客
02-24 2607
组合模式 概述 叶子节点进行相关的操作。 可以将这颗树理解成一个大的容器，容器里面包含很多的成员对象，这些成员对象即可是容器对象也可以是叶子对象。 但是由于容器对象和叶子对象在功能上面的区别，使得我们在使用的过程中必须要区分容器对象和叶子对象，但是这样就会给客户带来不必要的麻烦， 作为客户而已，它始终希望能够一致的对待容器对象和叶子对象。 定义： 又名部分整体模式，是用于把一组相似的对象当作一个单一的对象。 组合模式依据树形结构来组合对象，用来表示部分以及整体层次。 这种类型的设计模式
c# 组合模式
09-05
组合模式：将对象组合成树形结构以表示‘部分-整体’的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。需求中式体现部分与整体层次的结构时，统一地使用组合对象中的所有对象时，应该考虑使用...
JDK 1.8 ConcurrentHashMap 源码剖析
舒哥的blog
02-04 8768
转载两篇不错的文章： 第一篇： 前言 HashMap是我们平时开发过程中用的比较多的集合，但它是非线程安全的，在涉及到多线程并发的情况，进行put操作有可能会引起死循环，导致CPU利用率接近100%。 final HashMapString, String> map = new HashMapString, String>(2); for (int i = 0; i 10000
组合模式(Composite)
最新发布
LuckFairyLuckBaby的博客
04-23 1284
组合模式(Composite),将对象组合成树形结构以表示部分-整体的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性Component:组合中的对象声明接口，在适当情况下，实现所有类共有接口的默认行为。声明一个接口用于访问和管理Component的子部件Leaf:在组合中表示叶节点对象，叶节点没有子节点Composite:定义有枝节点行为，用来存储子部件，在Component接口中实现与子部件有关的操作，比如增加Add和删除Remove。
设计模式——组合模式
姑娘眼中的明月色，就只有你一人，轻轻望去，才能发现。
04-28 1696
组合模式 组合模式动机及定义 1.1模式动机 在面向对象系统中，我们常常会遇到一类具有“容器”特征对对象——即它们在充当普通对象对同时，又可作为其他对象对容器，这些对象成为容器对象，而那些只能充当普通对象的对象则称为叶子对象。在容器对象中即可以包含叶子对象，又可以包含容器对象，为了更好地解决容器对象和叶子对象之间的关系，使之操作更加简单，我们需要学习一种新的结构设计模式，即组合模式。组合模式实际要解决的问题是：对整体与个体的操作应一致，类似对文件夹与文件对操作。 ...
组合模式（结构型）
GSON的博客
03-29 1149
一、什么是组合模式 组合(Composite)模式是一种对象的行为模式。将对象组合成树形结构以表示“部分-整体”的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。 组合模式的本质：统一叶子对象和组合对象。 组合模式的目的：让客户端不再区分操作的是组合对象还是叶子对象，而是以一个统一的方式来操作。 二、组合模式的适用性 在开发中， 我们经常可能要递归构建树状的组合...
java组合模式
王朝虎的博客
01-23 1436
组合模式介绍使用场景优点表现形式实例 下面是正文 介绍 组合模式使用户对单个对象和组合对象的使用具有一致性。 屏蔽了容器对象与单个对象在使用时的差异，为客户提供统一的操作接口，从而降低客户代码与被调用对象的耦合关系，方便系统维护与扩展。 使用场景 当需求中体现部分与整体层次结构时，以及希望用户可以忽略组合对象与单个对象不同时，统一德使用组合结构中的所有对象时，可考虑使用组合模式。 优点 组合模...
详解设计模式：组合模式
栗筝i的博客
12-01 1553
组合模式（Composite Pattern），又叫部分整体模式，是 GoF 的 23 种设计模式中的一种结构型设计模式。 组合模式 是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。它创建了对象组的树形结构。 本篇内容包括：关于组合模式、组合模式实现 Demo
C++结构型模式-组合模式
灰太狼的小秘密
09-19 1778
C++实现组合模式
JavaScript 设计模式之组合模式
热门推荐
仇益阳的博客
12-02 1万+
引 我们知道地球和一些其他行星围绕着太阳旋转，也知道在一个原子中，有许多电子围绕着原子核旋转。我曾经想象，我们的太阳系也许是一个更大世界里的一个原子，地球只是围绕着太阳原子的一个电子。而我身上的每个原子又是一个星系，原子核就是这个星系中的恒星，电子是围绕着恒星旋转的行星。一个电子中也许还包含了另一个宇宙，虽然这个宇宙还不能被显微镜看到，但我相信它的存在。 也许这个想法有些异想天开，但在程序设计中，...
java常用设计模式-组合模式
08-26
java常用设计模式-组合模式 组合模式（Composite Pattern）是一种结构型设计模式，它允许你将对象组合成树形结构以表示“部分-整体”的层次结构。这种模式使得客户端可以统一对待单个对象和对象组合。在组合模式中...
组合模式1
08-08
介绍组合模式（Composite）将对象组合成树形结构以表示“部分-整体”的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。常见的场景有asp.
组合模式Demo
05-31
组合模式Demo
设计模式_组合模式.zip
07-30
组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的...
C++设计模式之组合模式
01-20
在GOF的《设计模式:可复用面向对象软件的基础》一书中对组合模式是这样说的：将对象组合成树形结构以表示“部分-整体”的层次结构。组合（Composite）模式使得用户对单个对象和组合对象的使用具有一致性。 组合模式...
设计模式实验报告-组合模式.docx
12-11
设计模式实验报告
c++设计模式-结构型模式-组合模式
06-16
c++设计模式-结构型模式-组合模式；qt工程；c++简单源码； 组合（Composite Pattern）模式的定义：有时又叫作整体-部分（Part-Whole）模式，它是一种将对象组合成树状的层次结构的模式，用来表示“整体-部分”的关系...
组合模式-空军指挥系统.zip
12-23
本资源包含一个由Java设计模式中的“组合模式”实现的“空军指挥系统”的全部源代码。注意：本资源含有的代码量比较大，对于急需“项目实战”的朋友很有帮助！需要的朋友可以下载哦！！！！！！！！！！
python组合模式
10-07
组合模式是一种设计模式，用于将对象组合成树形结构以表示部分-整体层次结构。该模式允许客户端统一处理单个对象和对象组合。在Python中实现组合模式可以通过创建一个抽象基类（Component），定义操作方法（operation）并标记为抽象方法。然后创建两个具体类（Composite和Leaf）分别实现抽象基类。Composite类可以包含其他Component对象，而Leaf类是最小的组成部分。通过这种方式，可以通过调用组合对象的操作方法，递归地调用每个组件的操作方法。 以下是一个使用Python实现组合模式的示例代码： ```python from abc import ABC, abstractmethod class Component(ABC): @abstractmethod def operation(self): pass class Composite(Component): def __init__(self): self.children = [] def add(self, component): self.children.append(component) def remove(self, component): self.children.remove(component) def operation(self): for child in self.children: child.operation() class Leaf(Component): def operation(self): print("Leaf operation") # 创建一个组合对象，并向其中添加两个叶子对象 composite = Composite() composite.add(Leaf()) composite.add(Leaf()) # 调用组合对象的操作方法 composite.operation() ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值