设计模式——命令模式（本质：封装请求）

一、示意性代码&&UML图：

 

 

 

 

 

命令角色：

//命令角色

public abstract class Command {
	protected Receiver receiver=null;
	
	public Command(Receiver receiver) {
		this.receiver=receiver;
	}

	public abstract void excute();
	

}

具体命令角色：

package 命令模式示意;

public class ConcreteCommand extends Command {

	public ConcreteCommand(Receiver receiver) {
		super(receiver);
	}

	@Override
	public void excute() {
		receiver.action();
		
	}

}

请求者角色：

package 命令模式示意;

public class Invoker {
	private Command command;
	public void setCommand(Command command) {
		this.command=command;
	}
	public void executeCommand() {
		command.excute();
	}

}

 

接收者角色：

package 命令模式示意;

public class Receiver {
	public void action() {
		System.out.println("接收者开始行动了！");
	}

}

 

客户端：

package 命令模式示意;

public class Client {

	public static void main(String[] args) {
		Invoker invoker=new Invoker();
		Receiver receiver=new Receiver();
		Command command=new ConcreteCommand(receiver);
		invoker.setCommand(command);
		
		invoker.executeCommand();

	}

}

 

二、课本松耦合烤羊肉串：

UML图：

 

 

 

package 松耦合烤羊肉串;

public abstract class Command {
	protected Barbecuer barbecuer=null;
	public Command(Barbecuer barbecuer) {
		this.barbecuer=barbecuer;
	}
	public abstract void executeCommand();

}
package 松耦合烤羊肉串;


public class BakeChickenWingCommand extends Command {
	public BakeChickenWingCommand(Barbecuer barbecuer) {
		super(barbecuer);
	}
	@Override
	public void executeCommand() {
		barbecuer.bakeChickenWing();
		
	}
}
package 松耦合烤羊肉串;


public class BakeMuttonCommand extends Command {

	public BakeMuttonCommand(Barbecuer barbecuer) {
		super(barbecuer);
	}

	@Override
	public void executeCommand() {
		barbecuer.bakeMutton();
		
	}

}
package 松耦合烤羊肉串;

import java.util.*;

public class Waiter {
	private List<Command> list=new ArrayList<Command>();
	public void execute() {
		for(Command command:list) {
			command.executeCommand();
		}
	}
	public void setCommand(Command command) {
		if(command.toString().equals("松耦合烤羊肉串.BakeMuttonCommand")) {
			System.out.println("羊肉串没有了,换鸡翅吧！");
		}else {
			list.add(command);
			System.out.println("增加订单："+command.toString());
		}
	}
	public void deleteCommand(Command command){
		list.remove(command);
		System.out.println("取消订单："+command.toString());
	}

}
package 松耦合烤羊肉串;

public class Barbecuer {
	public void bakeMutton() {
		System.out.println("烤羊肉串！");
	}
	public void bakeChickenWing() {
		System.out.println("烤鸡翅！");
	}

}
package 松耦合烤羊肉串;

public class Client {

	public static void main(String[] args) {
		
		
		Barbecuer barbecuer=new Barbecuer();
		Command c1=new BakeChickenWingCommand(barbecuer);
		Command c2=new BakeMuttonCommand(barbecuer);
		Command c3=new BakeMuttonCommand(barbecuer);
		Command c4=new BakeMuttonCommand(barbecuer);
		Command c5=new BakeChickenWingCommand(barbecuer);
		
		Waiter girl=new Waiter();
		girl.setCommand(c1);
		girl.setCommand(c2);
		girl.setCommand(c3);
		girl.setCommand(c4);
		girl.setCommand(c5);
		
		girl.deleteCommand(c2);
		
		girl.execute();

	}

}

三、PPT可撤销式计算器：（复习的时候发现这个命令写的不对，不符合开闭原则，命令子类应该具体addCommand、SubCommand。。。）

 

UML图：

 

 

 

package 可撤销式计算器;

import java.util.*;

public class User {
	private List<Command> list=null;
	private Calculator calculator=null;
	private int current=0;
	public User() {
		list=new ArrayList<Command>();
		calculator=new Calculator();
		current=0;
	}
	public void execuateCommand(char opType,int opData) {
		Command c=new ConcreteCommand(calculator, opType, opData);
		c.execute();
		list.add(c);
		current++;
	}
	public void undoExecute(int levels) {
		System.out.println("undo"+levels+"次.");
		for(int i=0;i<levels;i++) {
			if(current>0) {
				list.get(current-1).unExecute();
				//list.remove(current-1);
				current--;
			}
		}
	}
	public void redoExecute(int levels) {
		System.out.println("redo"+levels+"次.");
		for(int i=0;i<levels;i++) {
			if(current<list.size()) {
				list.get(current-1+1).execute();
				current++;
			}
		}
	}
	
	

}
package 可撤销式计算器;

public abstract class Command {
	/*私有成员还是放到子类中好*/
	public abstract void execute();
	public abstract void unExecute();
	
	
}
package 可撤销式计算器;

public class ConcreteCommand extends Command {
	private Calculator calculator=null;
	private char opType;
	private int opData;
	public ConcreteCommand(Calculator calculator, char opType, int opData) {
		this.calculator = calculator;
		this.opType = opType;
		this.opData = opData;
	}
	public char undo(char opType) {
		char  res;
		switch(opType) {
		case '+':
			res='-';
			break;
		case '-':
			res='+';
			break;
		case '*':
			res='/';
			break;
		default:
			res='*';
			break;
		}
		return res;
	}
	@Override
	public void execute() {
		calculator.operation(opType, opData);
	}
	@Override
	public void unExecute() {
		calculator.operation(undo(opType), opData);
	}

}
package 可撤销式计算器;

public class Calculator {
	private int tot=0;
	public void operation(char opType,int opData) {
		switch(opType) {
			case '+':
				tot+=opData;
				break;
			case '-':
				tot-=opData;
				break;
			case '*':
				tot*=opData;
				break;
			case '/':
			tot/=opData;
				break;
			default:
				System.out.println("运算符不合法！");
				break;
		}
		System.out.println("tot="+tot+",following:"+opType+opData);
	}

}
package 可撤销式计算器;

public class Client {

	public static void main(String[] args) {
		User user=new User();
		user.execuateCommand('+', 1);
		user.execuateCommand('+', 2);
		user.execuateCommand('*', 2);
		
		user.undoExecute(2);
		user.redoExecute(1);

	}

}

THE END;