设计模式第十四次作业——职责链模式、命令模式

最新推荐文章于 2022-10-21 12:02:19 发布

Sweet y y y y u

最新推荐文章于 2022-10-21 12:02:19 发布

阅读量218

点赞数

分类专栏：设计模式

本文链接：https://blog.csdn.net/weixin_43470016/article/details/106651886

版权

设计模式专栏收录该内容

14 篇文章 0 订阅

订阅专栏

迭代器模式——提供一种方法顺序访问一个集合对象中的各个元素，而又不暴漏该对象的内部表示
职责链模式：模式定义
使多个对象都有机会处理请求，从而避免请求的发送者和
接收者之间的耦合关系。将这些对象连成一条链，并沿着
这条链传递请求，直到有一个对象处它为止。

职责链模式——加薪代码实现

//代码一
public class main {
	public static void main(String[] args) {
		Manager m1=new Manager("小花");
		Manager m2=new Manager("波妞");
		Manager m3=new Manager("宗介");
		Request r1=new Request();
		r1.setRequestType("加薪");
		r1.setRequestContent("小虎请求加薪");
		r1.setNumber(1000);
		m1.GetResult("经理", r1);
		m2.GetResult("总监", r1);
		m3.GetResult("总经理", r1);
		Request r2=new Request();
		r2.setRequestType("请假");
		r2.setRequestContent("小兰请假");
		r2.setNumber(3);
		m1.GetResult("经理", r2);
		m2.GetResult("总监", r2);
		m3.GetResult("总经理", r2);
	}
}
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) {
		RequestContent = requestContent;
	}
	public int getNumber() {
		return number;
	}
	public void setNumber(int number) {
		this.number = number;
	}
	
}
//管理类
class Manager{
	protected String name;
	public Manager(String name) {
		this.name=name;
	}
	public void GetResult(String managerLevel,Request request) {
		System.out.println(request.getRequestType()+":"+request.getNumber());
		if(managerLevel=="经理") {
			if(request.getRequestType()=="请假"&&request.getNumber()<=2) {
				System.out.println("数量<=2,被批准");
			}else {
				System.out.println("数量>2,无权批准");
			}
		}else if(managerLevel=="总监"){
			if(request.getRequestType()=="请假"&&request.getNumber()<=5) {
				System.out.println("数量<=5,被批准");
			}else {
				System.out.println("数量>2,无权批准");
			}
		}else if(managerLevel=="总经理") {
			if(request.getRequestType()=="请假") {
				System.out.println("");
			}else if(request.getRequestType()=="加薪"&&request.getNumber()<=500) {
				System.out.println("加薪<=500，被批准");
			}else if(request.getRequestType()=="加薪"&&request.getNumber()>500) {
				System.out.println("加薪>500，无权批准");
			}
		}
	}
}

//代码二
public class main {
	public static void main(String[] args) {
		CommonManager m1=new CommonManager("小花");
		Majordomo m2=new Majordomo("波妞");
		GeneralManager m3=new GeneralManager("宗介");
		m1.SetSuperior(m2);
		m2.SetSuperior(m3);
		Request r1=new Request();
		r1.setRequestType("请假");
		r1.setRequestContent("小兰请假");
		r1.setNumber(1);
		m1.RequestApplications(r1);
		Request r2=new Request();
		r2.setRequestType("请假");
		r2.setRequestContent("小花请假");
		r2.setNumber(4);
		m1.RequestApplications(r2);
		Request r3=new Request();
		r3.setRequestType("加薪");
		r3.setRequestContent("小篮加薪");
		r3.setNumber(1000);
		m1.RequestApplications(r3);
	}
}
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) {
		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) {
		this.name=name;
	}
	protected void SetSuperior(Manager superior) {
		this.superior=superior;
	}
	abstract public void RequestApplications(Request request);
}
//经营者类
class CommonManager extends Manager{
	public CommonManager(String name) {
		super(name);
	}

	public void RequestApplications(Request request) {
		if(request.getRequestType()=="请假"&&request.getNumber()<=2) {
			System.out.println(name+":"+request.getRequestContent()+"数量"+request.getNumber()+"被批准");
			
		}else {
			if(superior!=null) {
				superior.RequestApplications(request);
			}
		}
		
	}
	
}
class Majordomo extends Manager{
	public Majordomo(String name) {
		super(name);
	}

	public void RequestApplications(Request request) {
		if(request.getRequestType()=="请假"&&request.getNumber()<=5) {
			System.out.println(name+":"+request.getRequestContent()+"数量"+request.getNumber()+"被批准");
			
		}else {
			if(superior!=null) {
				superior.RequestApplications(request);
			}
		}
		
	}
}
class GeneralManager extends Manager{
	public GeneralManager(String name) {
		super(name);
	}

	public void RequestApplications(Request request) {
		if(request.getRequestType()=="请假") {
			System.out.println(name+":"+request.getRequestContent()+"数量"+request.getNumber()+"被批准");
			
		}else if(request.getRequestType()=="加薪"&&request.getNumber()<=500){
			System.out.println(name+":"+request.getRequestContent()+"数量"+request.getNumber()+"被批准");
		}else {
			System.out.println(name+":"+request.getRequestContent()+"数量"+request.getNumber()+"再说吧");
		}
		
	}
}

职责链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避见请求的发送者和接收者之间的耦合关系。
将这个对象连成条链，并沿这条链传递该请求，直到有一个对象处理它为止。
这里发出这个请求的客户端并不知道这当中的哪个对象最终处理这个请求，这样系统的更改可以在不影响客户端的情况下动态地重新组织和分配责任。
在这里插入图片描述

//职责链模式示意代码
public class main {
	public static void main(String[] args) {
		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 []rs= {2,5,14,22,15,3,27,23};
		for(int i=0;i<rs.length;i++) {
			h1.HandRequest(rs[i]);
		}
		
	}
}
abstract class Handler{
	protected String name;
	protected Handler successor;//设置继任者
	public void SetSuccessor(Handler successor) {
		this.successor=successor;
	}
	public abstract void HandRequest(int request);
	public void setName(String name) {
		this.name=name;
	}
	public String getName(){
		return name;
	}
}
//具体处理类
class ConcreteHandler1 extends Handler{

	public void HandRequest(int request) {
		if(request>=0&&request<10) {
			System.out.println(this.getName()+"处理请求"+request);
		}else if(successor!=null) {
			successor.HandRequest(request);
		}
		
	}
	
}
class ConcreteHandler2 extends Handler{

	public void HandRequest(int request) {
		if(request>=10&&request<20) {
			System.out.println(this.getName()+"处理请求"+request);
		}else if(successor!=null) {
			successor.HandRequest(request);
		}
		
	}
	
}
class ConcreteHandler3 extends Handler{

	public void HandRequest(int request) {
		if(request>=20&&request<30) {
			System.out.println(this.getName()+"处理请求"+request);
		}else if(successor!=null) {
			successor.HandRequest(request);
		}
		
	}
	
}

命令（Command）模式

命令模式又称为行动（Action）模式或交易 (Transaction )模式。
命令模式把一个请求或者操作封装到一个对象中。命令模式允许系统使用不同的请求把客户端参数化; 对请求排队或者记录请求日志，可以提供命令的撤销和恢复功能。
命令模式是对命令的封装：把发出命令的责任和执行命令的责任分割开，委派给不同的对象。
命令模式允许请求的一方和接收的一方独立开来，使得请求的一方不必知道接收请求的一方的接口, 更不必知道请求是怎么被接收，以及操作是否被执行、何时被执行，以及是怎么被执行的。

命令模式——烧烤摊和烧烤店代码实现

实现一

public class main {
	public static void main(String[] args) {
		Barbercucer b=new Barbercucer();
		b.BakeMutton();
		b.BakeMutton();
		b.BakeMutton();
		b.BakeChickenWing();
		b.BakeMutton();
		b.BakeMutton();
		b.BakeChickenWing();
	}
}
class Barbercucer{
	public void BakeMutton() {
		System.out.println("烤羊肉串");
	}
	public void BakeChickenWing() {
		System.out.println("烤鸡翅");
	}
	
}

实现二

public class main {
	public static void main(String[] args) {
		Barbercucer b=new Barbercucer();
		Command c1=new BakeChickenCommand(b);
		Command c2=new BakeMuttonCommand(b);
		Command c3=new BakeMuttonCommand(b);
		Waiter w=new Waiter();
		w.SetOrder(c1);
		w.Notify();
		w.SetOrder(c2);
		w.Notify();
		w.SetOrder(c3);
		w.Notify();
	}
}
class Barbercucer{
	public void BakeMutton() {
		System.out.println("烤羊肉串");
	}
	public void BakeChickenWing() {
		System.out.println("烤鸡翅");
	}
	
}
//抽象命令类
abstract class Command{
	protected Barbercucer receiver;
	public Command(Barbercucer receiver) {
		this.receiver=receiver;
	}
	public abstract void ExcuteCommand();
}
//烤羊肉串
class BakeMuttonCommand extends Command{

	public BakeMuttonCommand(Barbercucer receiver) {
		super(receiver);
	}

	public void ExcuteCommand() {
		receiver.BakeMutton();
	}
}
//烤鸡翅
class BakeChickenCommand extends Command{

	public BakeChickenCommand(Barbercucer receiver) {
		super(receiver);
	}

	public void ExcuteCommand() {
		receiver.BakeChickenWing();
	}
}
//服务员类
class Waiter{
	private Command command;
	public void SetOrder(Command command) {
		this.command=command;
	}
	public void Notify() {
		command.ExcuteCommand();
	}
}

实现三——点完菜一次性通知

public class main {
	public static void main(String[] args) {
		Barbercucer b=new Barbercucer();
		Command c1=new BakeChickenCommand(b);
		Command c2=new BakeMuttonCommand(b);
		Command c3=new BakeMuttonCommand(b);
		waiterlst w=new waiterlst();
		w.SetOrder(c1);
		w.SetOrder(c2);
		w.SetOrder(c3);
		w.SetOrder(c1);
		w.CancelOrder(c1);
		w.Notify();
	}
}
class Barbercucer{
	public void BakeMutton() {
		System.out.println("烤羊肉串");
	}
	public void BakeChickenWing() {
		System.out.println("烤鸡翅");
	}
	
}
//抽象命令类
abstract class Command{
	protected Barbercucer receiver;
	public Command(Barbercucer receiver) {
		this.receiver=receiver;
	}
	public abstract void ExcuteCommand();
}
//烤羊肉串
class BakeMuttonCommand extends Command{

	public BakeMuttonCommand(Barbercucer receiver) {
		super(receiver);
	}

	public void ExcuteCommand() {
		receiver.BakeMutton();
	}
}
//烤鸡翅
class BakeChickenCommand extends Command{

	public BakeChickenCommand(Barbercucer receiver) {
		super(receiver);
	}

	public void ExcuteCommand() {
		receiver.BakeChickenWing();
	}
}
//服务员类
class waiterlst{
	private ArrayList<Command>orders=new ArrayList<Command>();
	public void SetOrder(Command command) {
		if(command.getClass().getName()=="Barbercucer.BakeChickenWingCommand") {
			System.out.println("服务员：鸡翅没有了");
		}else {
			orders.add(command);
			SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
			System.out.println("增加订单："+command.getClass().getName()+"时间："+df.format(new Date()));
		}
	}
	public void CancelOrder(Command command) {
		orders.remove(command);
		SimpleDateFormat df=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
		System.out.println("取消订单："+command.getClass().getName()+"时间："+df.format(new Date()));
	
	}
	public void Notify() {
		Iterator<Command>cmd=orders.iterator();
		while(cmd.hasNext()) {
			cmd.next().ExcuteCommand();
		}
	}
}

命市令模式基本介绍

1)命令模式(Command Pattern):在软件设计中，经常需要向某些对象发送请求，但是并不知道请求的接收者是谁，也不知道被请求的操作是那个，只需在程序运行时指定具体的请求接收者即可，此时，可以使用命令模式来进行设计。
2)命令模式使得请求发送者与请求接收者消除彼比之间的耦合，让对象之间的调用关系更加灵话，实现解耦。
3)在命令模式中，将一个请求封装为一个对象，以便使用不同参数来表示不同的请求(即命令)，同时命令模式也支持可撤销的操作。
4)Invoker是调用者(将军), Receiver是被调用者(士兵),MyCommand是命令，实现了Command接口，持有接收对象。
在这里插入图片描述

命令模式代码实现

public class main {
	public static void main(String[] args) {
		Receiver r=new Receiver();
		Command c=new ConcreteCommand(r);
		Invoker i=new Invoker();
		i.SetCommand(c);
		i.ExecuteCmommand();
		}
}
abstract class Command{
	protected Receiver receiver;
	public Command(Receiver receiver) {
		this.receiver=receiver;
	}
	abstract public void Execute();
}
class ConcreteCommand extends Command{
	public ConcreteCommand(Receiver receiver) {
		super(receiver);
	}
	public void Execute() {
		receiver.Action();
		
	}
	
}
//Invoker类，要求该命令执行这个请求
class Invoker{
	private Command command;
	public void SetCommand(Command commannd) {
		this.command=commannd;
	}
	public void ExecuteCmommand() {
		command.Execute();
	}
}
//Receiver类，知道如何实施与执行一个与请求相关的操作，任何类都可以作为一个接收者
class Receiver{
	public void Action() {
		System.out.println("执行请求!");
	}
}

命令模式优点

命令模式允许请求的一方和接收请求的一方能够独立演化，从而有以下的优点：
命令模式使新的命令很容易地被加入到系统里。
允许接收请求的一方决定是否要否决（Veto）请求。
能较容易地设计一个命令队列。
可以容易地实现对请求的Undo和Redo。
在需要的情况下，可以较容易地将命令记入日志。
命令模式把请求一个操作的对象与执行操作的对象分割开。
命令类与其他任何別的类一样，可以修改和推广。

Sweet y y y y u

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
打赏
0
评论
设计模式第十四次作业——职责链模式、命令模式

迭代器模式——提供一种方法顺序访问一个集合对象中的各个元素，而又不暴漏该对象的内部表示职责链模式：模式定义使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递请求，直到有一个对象处它为止。职责链模式——加薪代码实现//代码一public class main { public static void main(String[] args) { Manager m1=new Manager("小花"); Manager m2=n
复制链接

扫一扫