设计模式 —— 迭代器模式（职责链模式）

最新推荐文章于 2023-02-15 15:09:54 发布
最新推荐文章于 2023-02-15 15:09:54 发布
阅读量226 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yu_Nan___/article/details/106649697
版权

迭代器模式（职责链模式）

迭代器模式(Iterator Pattern)：提供一种方法来访问聚合对象，而不用暴露这个对象的内部表示，其别名为游标(Cursor)。迭代器模式是一种对象行为型模式。
在这里插入图片描述 案例：加薪申请、上报与审批
源代码：V1.0

package org.zangyu.Iterator;

public class Iterator {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Manager xz1 =new Manager("小臧1");//三个管理者
		Manager xz2 =new Manager("小臧2");
		Manager xz3 =new Manager("小臧3");
		Request request=new Request();//小菜请求加薪1000
		request.setRequesttype("加新");
		request.setRequestcontent("小菜请求加薪");
		request.setNumber(1000);
		xz1.GetResult("经理", request);
		xz2.GetResult("总监", request);
		xz3.GetResult("总经理", request);
		System.out.println("---------------");
		Request request1=new Request();//小菜请假三天
		request1.setRequesttype("请假");
		request1.setRequestcontent("小菜请假3天");
		request1.setNumber(3);
		xz1.GetResult("经理", request1);
		xz2.GetResult("总监", request1);
		xz3.GetResult("总经理", request1);
		
	}

}
//申请：小菜请求加薪2000/小菜请假3天
class Request{
	private String requesttype;//申请类别
	private String requestcontent;//申请内容
	private int number;//数量
	public String getRequesttype() {
		return requesttype;
	}
	public void setRequesttype(String requesttype) {
		this.requesttype = requesttype;
	}
	public String getRequestcontent() {
		return requestcontent;
	}
	public void setRequestcontent(String requestcontent) {
		this.requestcontent = requestcontent;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	
	
}
class Manager{
	protected String name;

	public Manager(String name) {
		super();
		this.name = name;
	}
	public void GetResult(String managerlevel,Request request)
	{
		System.out.println(request.getRequesttype()+";"+request.getNumber());
        if(managerlevel.equals("经理"))	{
            if(request.getRequesttype().equals("请假")&&request.getNumber()<=2)
            {
            	System.out.println("数量<=2,被批准");
            }else {
            	System.out.println("数量>2,无权批准");
            }
        }else if(managerlevel.equals("总监")) {
        	if(request.getRequesttype().equals("请假")&&request.getNumber()<=5)
            {
            	System.out.println("数量<=5,被批准");
            }else {
            	System.out.println("数量>5,无权批准");
            }
        }else if(managerlevel.equals("总经理")) {
        	if(request.getRequesttype().equals("请假"))
        	{
        		System.out.println("请假，被批准");
        	}else if(request.getRequesttype().equals("加薪")&&request.getNumber()<=500)
            {
            	System.out.println("加新<500,被批准");
            }else if(request.getRequesttype().equals("加薪")&&request.getNumber()>500){
            	System.out.println("加新>500,无权批准");
            }
        }
	}
	
}

manager类的GetResult方法比较长，有太多分支，承担的太多的职责，修改功能时需要修改类，违背了开闭原则；
解决：重构加新代码
源代码：V2.0（职责链模式）
在这里插入图片描述

package org.zangyu.Iterator;

public class Iterator2 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		CommonManager xz1 =new CommonManager("小臧1");//三个管理者
		Majordomo xz2 =new Majordomo("小臧2");
		GeneralManager xz3 =new GeneralManager("小臧3");
		//根据实际情况设置上级
		xz1.setSuperior(xz2);
		xz2.setSuperior(xz3);
		
		
		Request request=new Request();//小菜请求加薪1000
		request.setRequesttype("加新");
		request.setRequestcontent("小菜请求加薪");
		request.setNumber(1000);
		xz1.RequestApplications(request);
		
		Request request1=new Request();//小菜请假
		request1.setRequesttype("请假");
		request1.setRequestcontent("小菜请假2天");
		request1.setNumber(2);
		xz1.RequestApplications(request1);
		
		Request request2=new Request();//小菜请假
		request2.setRequesttype("请假");
		request2.setRequestcontent("小菜请假5天");
		request2.setNumber(5);
		xz1.RequestApplications(request2);
	}

}
//申请：小菜请求加薪2000/小菜请假3天
class Request{
	private String requesttype;//申请类别
	private String requestcontent;//申请内容
	private int number;//数量
	public String getRequesttype() {
		return requesttype;
	}
	public void setRequesttype(String requesttype) {
		this.requesttype = requesttype;
	}
	public String getRequestcontent() {
		return requestcontent;
	}
	public void setRequestcontent(String requestcontent) {
		this.requestcontent = requestcontent;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	
	
}
abstract class Manager{
	protected String name;
    protected Manager superior;
	public Manager(String name) {
		super();
		this.name = name;
	}
	
	public Manager getSuperior() {
		return superior;
	}

	public void setSuperior(Manager superior) {
		this.superior = superior;
	}
    abstract public void RequestApplications(Request request);
	
}
class CommonManager extends Manager{

	public CommonManager(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void RequestApplications(Request request) {
		// TODO Auto-generated method stub
		if(request.getRequesttype().equals("请假")&&request.getNumber()<=2)
		{
			System.out.println(this.name+"、"+request.getRequestcontent()+"数量"+request.getNumber()+"被批准");
		}else {//其余申请都需转到上级
			if(superior!=null) {
				superior.RequestApplications(request);
			}
		}	
	}
}
class Majordomo extends Manager{

	public Majordomo(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void RequestApplications(Request request) {
		// TODO Auto-generated method stub
		if(request.getRequesttype().equals("请假")&&request.getNumber()<=5)
		{
			System.out.println(this.name+"、"+request.getRequestcontent()+"数量"+request.getNumber()+"被批准");
		}else {//其余申请都需转到上级
			if(superior!=null) {
				superior.RequestApplications(request);
			}
		}	
	}
	
}
class GeneralManager extends Manager{

	public GeneralManager(String name) {
		super(name);
		// TODO Auto-generated constructor stub
	}

	@Override
	public void RequestApplications(Request request) {
		// TODO Auto-generated method stub
		if(request.getRequesttype().equals("请假")&&request.getNumber()<=2)
		{
			System.out.println(this.name+"、"+request.getRequestcontent()+"数量"+request.getNumber()+"被批准");
		}else if(request.getRequesttype().equals("加薪")&&request.getNumber()<=500){
			System.out.println(this.name+":"+request.getRequestcontent()+"数量"+request.getNumber());
		}else {
			System.out.println(this.name+":"+request.getRequestcontent()+"数量"+request.getNumber()+"再说");
		}	
	}
}

职责链模式框架
源代码：V1.0

package org.zangyu.Iterator;

public class Iterator3 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
     Handler h1 =new  ConcreteHandler1();
     h1.setName("审批人1");
     Handler h2 =new  ConcreteHandler2();
     h2.setName("审批人2");
     Handler h3 =new  ConcreteHandler3();
     h3.setName("审批人3");
     //设置职责链上的关系
     h1.setSuccessor(h2);
     h2.setSuccessor(h3);
     int[] requests= {2,5,14,22,18,3,27,20};
     for(int i=0;i<requests.length;i++) {
    	 h1.HandleRequest(requests[i]);
     }
	}

}
abstract class Handler{
	protected String name;
	protected Handler successor;//设置继承者
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Handler getSuccessor() {
		return successor;
	}
	public void setSuccessor(Handler successor) {
		this.successor = successor;
	}
	public abstract void HandleRequest(int request);
	//处理请求的抽象方法
}
class ConcreteHandler1 extends Handler{//具体处理者1

	@Override
	public void HandleRequest(int request) {
		// TODO Auto-generated method stub
		if(request>=0&&request<10) {
			System.out.println(this.getName()+"处理请求"+request);
		}else if(successor!=null) {
			//转移到下一位去处理
			successor.HandleRequest(request);
		}
	}
}
class ConcreteHandler2 extends Handler{//具体处理者2

	@Override
	public void HandleRequest(int request) {
		// TODO Auto-generated method stub
		if(request>=10&&request<20) {
			System.out.println(this.getName()+"处理请求"+request);
		}else if(successor!=null) {
			//转移到下一位去处理
			successor.HandleRequest(request);
		}
	}
}
class ConcreteHandler3 extends Handler{//具体处理者2

	@Override
	public void HandleRequest(int request) {
		// TODO Auto-generated method stub
		if(request>=20&&request<30) {
			System.out.println(this.getName()+"处理请求"+request);
		}else if(successor!=null) {
			//转移到下一位去处理
			successor.HandleRequest(request);
		}
	}
}

职责链优缺点

优点：

客户端无需知道哪一个对象处理它的请求
请求处理对象维持一个指向后继者的引用，简化对象的连接
可通过在运行时对该链进行动态增加or删除改变处理一个请求的职责
系统增加具体处理者无需修改原有代码，只需要客户端重新创建链即可，满足开闭原则
缺点：
a)没有明确接收者，不能保证被处理
b)对请求链长的职责链，系统性能收到影响

职责链适用环境

例如：web应用中创建多个过滤器Filter链来对请求进行过滤
工作流系统中实现办公的分级审批
异常处理机制，不同的catch子句构成了一条处理异常对象的职责链

有多个对象可以处理请求
在不明确指定接收者的情况下向多个对象中的一个提交一个请求
客户端动态指定一组对象处理请求，而且还可以改变链中的执行顺序
Yu_Nan___
关注
专栏目录
设计模式——设计模式概述
冯Jungle的个人博客
10-12 2万+
软件设计模式（Design pattern），又称设计模式，是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。设计模式主要是为了解决某类重复出现的问题而出现的一套成功或有效的解决方案。设计模式提供一种讨论软件设计的公共语言，使得熟练设计者的设计经验可以被初学者和其他设计者掌握。设计模式还为软件重构提供了目标。 1.设计模式由来 软件设计模式源自于建筑学。积淀了几千年的建筑学工...
golang设计模式——简介
qq_39280718的博客
09-03 584
设计模式是面向对象软件的设计经验，是解决特定问题的一系列套路。
图形学优化_3: 责任链模式和迭代器模式
LandscapeMi
12-21 575
对象行为模式，把请求以链的形式传递给对象 迭代器模式 包装了iterator 也可以看做adapter模式 顺序访问一个聚合对象中各元素的方法
（Boolan）C++设计模式 <十一> ——组合模式（Composite）、迭代器（Iterator）和责任链（Chain of Resposibility）
Toonle的专栏
08-23 665
“数据结构”模式 常常有一些组建在内部具有特定的数据结构，如果让客户程序依赖这些特定的数据结构，将极大的破坏组件的复用。这时候，将这些数据结构封装在内部，在外部提供统一的接口，来实现与特定数据结构无关的访问，是一种行之有效的解决方案。 典型模式 Composite Iterator Chain of Responsibility 组合模式（Composite） 将对象组合成树形结构以表示“
设计模式-行为型模式讲解一（责任链、命令、迭代器）
小毕超博客
09-21 4499
一、行为型设计模式 上篇，我们呢讲解了结构型设计模式，包括 适配器模式、桥接模式、组合模式、装饰者模式、享元模式、代理模式、外观模式。 适配器、桥接、组合、享元：https://blog.csdn.net/qq_43692950/article/details/120248267 装饰者、外观、代理：https://blog.csdn.net/qq_43692950/article/details/120249265 这篇文章我们来讲解下行为型设计模式：主要用于描述类或对象之间的交互或职责的分配，为设计
【设计模式】状态模式、责任链模式、迭代器模式、解释器模式
SWELER的博客
01-22 277
责任链模式为请求创建了一个接收者对象的链。每个接受者都含有另一个接收者的引用，如果一个接收者不能处理他的请求，就会把这个请求发送给他的下一个接受者了，以此类推。客户只需要将请求发送到责任链上就可以了，不必关心请求处理的细节和请求的传递过程，实现了请求的发送者和请求的处理者解耦。将请求和处理分开，实现解耦，提高系统的灵活性简化了对象，使对象不需要知道链的结构调试不方便。采用了类似递归的方式，调试时逻辑可能比较复杂。
迭代器模式
猎户星座
05-31 149
一、前言 相信相信的力量！ 从懵懂的少年，到拿起键盘，可以写一个HelloWorld。多数人在这并不会感觉有多难，也不会认为做不出来。因为这样的例子，有老师的指导、有书本的例子、有前人的经验。但随着你的开发时间越来越长，要解决更复杂的问题或者技术创新，因此在网上搜了几天几夜都没有答案，这个时候是否想过放弃，还是一直坚持不断的尝试一点点完成自己心里要的结果。往往这种没有前车之鉴需要自己解决问题的时候，可能真的会折磨到要崩溃，但你要愿意执着、愿意倔强，愿意选择相信相信的力量，就一定能解决。哪怕解决不了，也可
C++设计模式——职责链模式（responsibility chain pattern）
净无邪博客
10-24 634
一、原理讲解 1.1意图 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。 1.2应用场景 有多个对象可以处理一个请求，哪个对象处理该请求运行时自动确定； 你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求； 可处理一个请求的对象集合应被动态指定； 1.3结构图（UML图） 1.4代码实现步骤 a1 定义接口迭代器类IHandler，定义一个接口函数request()； a2 定义一个具体处理类Ha
设计模式——JAVA.docx
04-03
- **行为型模式**（共11种）：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。 每一种设计模式都有其特定的应用场景和解决的...
《java设计模式》课后习题模拟试题解答——刘伟.zip
12-26
3. **行为型模式**：包括策略（Strategy）、模板方法（Template Method）、观察者（Observer）、迭代器（Iterator）、访问者（Visitor）、责任链（Chain of Responsibility）、命令（Command）、备忘录（Memento）、...
设计模式学习-组合模式,迭代器,职责链
qq_41795143的博客
12-30 249
设计模式学习-组合模式,迭代器,职责链 三种模式应用数据结构实现，可归结为数据结构模式 组合模式(Composite) 定义 将对象组合成树形结构以表示“部分-整体”的层次结构。Composite使得用户对单个对象和组合对象的使用具有一致性(稳定) 通俗概括 对于部分对象组合操作问题,针对执行组合多与少的问题，将待操作对象组织为树结构，使得对象组合调用一致。 模式示意图 迭代器(Iterator) 定义 提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示
设计模式之迭代器模式
weixin_45362971的博客
09-21 116
基本介绍 是常用的设计模式，属性行为型模式 如果我们的集合元素是用不同的方式实现的，有数组，还有java的集合类，或者还有其他方式，当客户端要遍历这些集合元素的时候就要使用多种遍历方式，而且还会暴露元素的内部结构，可以考虑使用迭代器模式解决 迭代器模式，提供一种遍历集合元素的统一接口，用一致的方法遍历集合元素，不需要知道集合对象的底层表示，即：不暴露其内部结构 角色及职责 Iterator：迭代器接口，是系统提供，含nextNext，next，remove ConcreteIterator：具体的迭代
设计模式：迭代器模式
OceanStar的博客
01-06 185
原理 迭代器模式（Iterator Design Pattern），也叫作游标模式（Cursor Design Pattern）。它是用来遍历集合对象的。这里说的“集合对象”也可以叫做“容器”、“聚合对象”，实际上就是包含一组对象的对象，比如数组、链表、树、图、调表等。迭代器模式将集合对象的遍历操作从集合类中拆分出来，放到迭代器类中，让两者的职责更加单一。 迭代器是用来遍历容器的，所以，一个完整的迭代器模式一般会涉及容器和容器迭代器两部分内容。为了达到基于接口而非实现编程的目的，容器又包含容器接口、容器实现
多次代码迭代，应用责任链设计模式
m0_73311735的博客
02-11 75
责任链模式是一种理解上比较简单的行为设计模式，它允许开发者通过处理者链进行顺序发送，每个链节点在收到请求后，具备两种能力：对其进行处理（消费）将其传递给链上的下个处理者当你想要让一个以上的对象有机会能处理某个请求时，就可以使用责任链模式。通过责任链模式，为某个请求创建一个对象链，每个对象链依序检查此请求，并对其进行处理，或者将它传给链中的下一个对象。责任链到底解决了什么问题？前置检查，减少不必要的后置代码逻辑。
设计模式：（迭代器模式）
qq_51447436的博客
04-21 7837
设计模式：（迭代器模式）
学习设计模式之迭代模式
南淮北安的博客
05-07 416
文章目录一、定义二、问题背景三、迭代器模式遍历组织结构1. 工程结构2. 代码实现3. 测试验证四、总结 一、定义 迭代器模式，常见的就是我们日常使用的iterator遍历。虽然这个设计模式在我们的实际业务开发中的场景并不多，但却几乎每天都要使用jdk为我们提供的list集合遍历。另外增强的for循环虽然是循环输出数据，但是他不是迭代器模式。迭代器模式的特点是实现Iterable接口，通过next的方式获取集合元素，同时具备对元素的删除等操作。而增强的for循环是不可以的。 这种设计模式的优点是可以让我们
设计模式——迭代模式
XHY的博客
10-14 290
定义 迭代器模式（Iterator），提供一种方法顺序访问一个聚合对象中的各种元素，而又不暴露该对象的内部表示。 以List为例我们都知道List最常用的有两种结构，一种是链表一种是数组，数组通过下标去遍历元素，而链表则通过访问下个节点去遍历元素，也就是说这两个遍历元素的方式是不同的如果我们要使用就需要我们熟悉我们要用的容器的数据结构，但这种方式并不可取。增加了学习成本已经降低的程序的通用性和可扩展性。因此我们引入迭代器模式来隐藏具体的遍历细节，从而通过一个方式就可以遍历所有容器元素 结构和实现 结构
设计模式第六讲：责任链模式和迭代器模式详解
最新发布
Linuxhus的博客
02-15 547
(1). 定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。PS：责任链模式也叫职责链模式。在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，所以责任链将请求的发送者和请求的处理者解耦了。(2). 优点：A. 降低了对象之间的耦合度。
设计模式-05.03-行为型-状态&迭代器
youthlql的博客
09-17 611
文章目录状态模式【重要】什么是有限状态机？状态机实现方式一：分支逻辑法状态机实现方式二：查表法状态机实现方式三：状态模式迭代器模式【重要】迭代器模式的原理和实现迭代器模式的优势在遍历的同时增删集合元素会发生什么？如何应对遍历时改变集合导致的未决行为？如何在遍历的同时安全地删除集合元素？如何设计实现一个支持“快照”功能的iterator？问题描述解决方案一解决方案二 1、文章可能会优先更新在Github，个人博客【包括文章纠错与增加内容】。其它平台会晚一段时间。个人博客备用地址 2、如果Github很卡，可
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Yu_Nan___

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值