`
seaizon
  • 浏览: 145250 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

研磨设计模式之命令模式-3(转)

设计模式Blog 
阅读更多

3.3  可撤销的操作

        可撤销操作的意思就是：放弃该操作，回到未执行该操作前的状态 。这个功能是一个非常重要的功能，几乎所有GUI应用里面都有撤消操作的功能。GUI的菜单是命令模式最典型的应用之一，所以你总是能在菜单上找到撤销这样的菜单项。
        既然这么常用，那该如何实现呢？
        有两种基本的思路来实现可撤销的操作，一种是补偿式，又称反操作式 ：比如被撤销的操作是加的功能，那撤消的实现就变成减的功能；同理被撤销的操作是打开的功能，那么撤销的实现就变成关闭的功能。
        另外一种方式是存储恢复式 ，意思就是把操作前的状态记录下来，然后要撤销操作的时候就直接恢复回去就可以了。
        这里先讲第一种方式，就是补偿式或者反操作式，第二种方式放到备忘录模式中去讲解。为了让大家更好的理解可撤销操作的功能，还是用一个例子来说明会比较清楚。
1：范例需求
        考虑一个计算器的功能，最简单的那种，只能实现加减法运算，现在要让这个计算器支持可撤销的操作。
2：补偿式或者反操作式的解决方案
（1）在实现命令接口之前，先来定义真正实现计算的接口，没有它命令什么都做不了，操作运算的接口的示例代码如下：

Java代码
  1. /**  
  2.  * 操作运算的接口  
  3.  */   
  4. public   interface  OperationApi {  
  5.     /**  
  6.      * 获取计算完成后的结果  
  7.      * @return 计算完成后的结果  
  8.      */   
  9.     public   int  getResult();  
  10.     /**  
  11.      * 设置计算开始的初始值  
  12.      * @param result 计算开始的初始值  
  13.      */   
  14.     public   void  setResult( int  result);  
  15.     /**  
  16.      * 执行加法  
  17.      * @param num 需要加的数  
  18.      */   
  19.     public   void  add( int  num);  
  20.     /**  
  21.      * 执行减法  
  22.      * @param num 需要减的数  
  23.      */   
  24.     public   void  substract( int  num);  
  25. }   
/**
 * 操作运算的接口
 */
public interface OperationApi {
	/**
	 * 获取计算完成后的结果
	 * @return 计算完成后的结果
	 */
	public int getResult();
	/**
	 * 设置计算开始的初始值
	 * @param result 计算开始的初始值
	 */
	public void setResult(int result);
	/**
	 * 执行加法
	 * @param num 需要加的数
	 */
	public void add(int num);
	/**
	 * 执行减法
	 * @param num 需要减的数
	 */
	public void substract(int num);
}

 

定义了接口，来看看真正执行加减法的实现，示例代码如下：

Java代码
  1. /**  
  2.  * 运算类，真正实现加减法运算  
  3.  */   
  4. public   class  Operation  implements  OperationApi{  
  5.     /**  
  6.      * 记录运算的结果  
  7.      */   
  8.     private   int  result;  
  9.     public   int  getResult() {  
  10.         return  result;  
  11.     }  
  12.     public   void  setResult( int  result) {  
  13.         this .result = result;  
  14.     }     
  15.     <strong>public   void  add( int  num){  
  16.         //实现加法功能   
  17.         result += num;  
  18.     }  
  19.     public   void  substract( int  num){  
  20.         //实现减法功能   
  21.         result -= num;  
  22.     }</strong>  
  23. }   
/**
 * 运算类，真正实现加减法运算
 */
public class Operation implements OperationApi{
	/**
	 * 记录运算的结果
	 */
	private int result;
	public int getResult() {
		return result;
	}
	public void setResult(int result) {
		this.result = result;
	}	
	public void add(int num){
		//实现加法功能
		result += num;
	}
	public void substract(int num){
		//实现减法功能
		result -= num;
	}

}

 （2）接下来，来抽象命令接口，由于要支持可撤销的功能，所以除了跟前面一样定义一个执行方法外，还需要定义一个撤销操作的方法，示例代码如下：

Java代码
  1. /**  
  2.  * 命令接口，声明执行的操作，支持可撤销操作  
  3.  */   
  4. public   interface  Command {  
  5.     /**  
  6.      * 执行命令对应的操作  
  7.      */   
  8.     public   void  execute();  
  9.     /**  
  10.      * 执行撤销命令对应的操作  
  11.      */   
  12.     public   void  undo();  
  13. }   
/**
 * 命令接口，声明执行的操作，支持可撤销操作
 */
public interface Command {
	/**
	 * 执行命令对应的操作
	 */
	public void execute();
	/**
	 * 执行撤销命令对应的操作
	 */
	public void undo();
}

 （3）应该来实现命令了，具体的命令分成了加法命令和减法命令，先来看看加法命令的实现，示例代码如下：

Java代码
  1. /**  
  2.  * 具体的加法命令实现对象  
  3.  */   
  4. public   class  AddCommand  implements  Command{  
  5.     /**  
  6.      * 持有具体执行计算的对象  
  7.      */   
  8.     private  OperationApi operation =  null ;  
  9.     /**  
  10.      * 操作的数据，也就是要加上的数据  
  11.      */   
  12.     private   int  opeNum;  
  13.       
  14.     <strong>public   void  execute() {  
  15.         //转调接收者去真正执行功能，这个命令是做加法   
  16.         this .operation.add(opeNum);  
  17.     }  
  18.     public   void  undo() {  
  19.         //转调接收者去真正执行功能   
  20.         //命令本身是做加法，那么撤销的时候就是做减法了   
  21.         this .operation.substract(opeNum);  
  22.     }</strong>  
  23.               /**  
  24.      * 构造方法，传入具体执行计算的对象  
  25.      * @param operation 具体执行计算的对象  
  26.      * @param opeNum 要加上的数据  
  27.      */   
  28.     public  AddCommand(OperationApi operation, int  opeNum){  
  29.         this .operation = operation;  
  30.         this .opeNum = opeNum;  
  31.     }  
  32. }   
/**
 * 具体的加法命令实现对象
 */
public class AddCommand implements Command{
	/**
	 * 持有具体执行计算的对象
	 */
	private OperationApi operation = null;
	/**
	 * 操作的数据，也就是要加上的数据
	 */
	private int opeNum;
	
	public void execute() {
		//转调接收者去真正执行功能，这个命令是做加法
		this.operation.add(opeNum);
	}
	public void undo() {
		//转调接收者去真正执行功能
		//命令本身是做加法，那么撤销的时候就是做减法了
		this.operation.substract(opeNum);
	}

              /**
	 * 构造方法，传入具体执行计算的对象
	 * @param operation 具体执行计算的对象
	 * @param opeNum 要加上的数据
	 */
	public AddCommand(OperationApi operation,int opeNum){
		this.operation = operation;
		this.opeNum = opeNum;
	}
}

 

减法命令和加法类似，只是在实现的时候和加法反过来了，示例代码如下：

Java代码
  1. /**  
  2.  * 具体的减法命令实现对象  
  3.  */   
  4. public   class  SubstractCommand  implements  Command{  
  5.     /**  
  6.      * 持有具体执行计算的对象  
  7.      */   
  8.     private  OperationApi operation =  null ;  
  9.     /**  
  10.      * 操作的数据，也就是要减去的数据  
  11.      */   
  12.     private   int  opeNum;  
  13.     /**  
  14.      * 构造方法，传入具体执行计算的对象  
  15.      * @param operation 具体执行计算的对象  
  16.      * @param opeNum 要减去的数据  
  17.      */   
  18.     public  SubstractCommand(OperationApi operation, int  opeNum){  
  19.         this .operation = operation;  
  20.         this .opeNum = opeNum;  
  21.     }     
  22.       
  23.     <strong>public   void  execute() {  
  24.         //转调接收者去真正执行功能，这个命令是做减法   
  25.         this .operation.substract(opeNum);  
  26.     }     
  27.     public   void  undo() {  
  28.         //转调接收者去真正执行功能   
  29.         //命令本身是做减法，那么撤销的时候就是做加法了   
  30.         this .operation.add(opeNum);  
  31.     }</strong>  
  32. }   
/**
 * 具体的减法命令实现对象
 */
public class SubstractCommand implements Command{
	/**
	 * 持有具体执行计算的对象
	 */
	private OperationApi operation = null;
	/**
	 * 操作的数据，也就是要减去的数据
	 */
	private int opeNum;
	/**
	 * 构造方法，传入具体执行计算的对象
	 * @param operation 具体执行计算的对象
	 * @param opeNum 要减去的数据
	 */
	public SubstractCommand(OperationApi operation,int opeNum){
		this.operation = operation;
		this.opeNum = opeNum;
	}	
	
	public void execute() {
		//转调接收者去真正执行功能，这个命令是做减法
		this.operation.substract(opeNum);
	}	
	public void undo() {
		//转调接收者去真正执行功能
		//命令本身是做减法，那么撤销的时候就是做加法了
		this.operation.add(opeNum);
	}

}

（4）接下来应该看看计算器了，计算器就相当于Invoker，持有多个命令对象，计算器是实现可撤销操作的地方。
为了大家更好的理解可撤销的功能，先来看看不加可撤销操作的计算器类什么样子，然后再添加上可撤销的功能示例。示例代码如下：

Java代码
  1. /**  
  2.  * 计算器类，计算器上有加法按钮、减法按钮  
  3.  */   
  4. public   class  Calculator {  
  5.     /**  
  6.      * 持有执行加法的命令对象  
  7.      */   
  8.     private  Command addCmd =  null ;  
  9.     /**  
  10.      * 持有执行减法的命令对象  
  11.      */   
  12.     private  Command substractCmd =  null ;  
  13.     /**  
  14.      * 设置执行加法的命令对象  
  15.      * @param addCmd 执行加法的命令对象  
  16.      */   
  17.     public   void  setAddCmd(Command addCmd) {  
  18.         this .addCmd = addCmd;  
  19.     }  
  20.     /**  
  21.      * 设置执行减法的命令对象  
  22.      * @param substractCmd 执行减法的命令对象  
  23.      */   
  24.     public   void  setSubstractCmd(Command substractCmd) {  
  25.         this .substractCmd = substractCmd;  
  26.     }     
  27.     /**  
  28.      * 提供给客户使用，执行加法功能  
  29.      */   
  30.     public   void  addPressed(){  
  31.         this .addCmd.execute();  
  32.     }  
  33.     /**  
  34.      * 提供给客户使用，执行减法功能  
  35.      */   
  36.     public   void  substractPressed(){  
  37.         this .substractCmd.execute();  
  38.     }  
  39. }   
/**
 * 计算器类，计算器上有加法按钮、减法按钮
 */
public class Calculator {
	/**
	 * 持有执行加法的命令对象
	 */
	private Command addCmd = null;
	/**
	 * 持有执行减法的命令对象
	 */
	private Command substractCmd = null;
	/**
	 * 设置执行加法的命令对象
	 * @param addCmd 执行加法的命令对象
	 */
	public void setAddCmd(Command addCmd) {
		this.addCmd = addCmd;
	}
	/**
	 * 设置执行减法的命令对象
	 * @param substractCmd 执行减法的命令对象
	 */
	public void setSubstractCmd(Command substractCmd) {
		this.substractCmd = substractCmd;
	}	
	/**
	 * 提供给客户使用，执行加法功能
	 */
	public void addPressed(){
		this.addCmd.execute();
	}
	/**
	 * 提供给客户使用，执行减法功能
	 */
	public void substractPressed(){
		this.substractCmd.execute();
	}
}

 

        目前看起来跟前面的例子实现得差不多，现在就在这个基本的实现上来添加可撤销操作的功能。
要想实现可撤销操作，首先就需要把操作过的命令记录下来，形成命令的历史列表，撤销的时候就从最后一个开始执行撤销。因此我们先在计算器类里面加上命令历史列表，示例代码如下：

Java代码
  1. /**  
  2. * 命令的操作的历史记录，在撤销时候用  
  3. */   
  4. private  List<Command> undoCmds =  new  ArrayList<Command>();   
/**
* 命令的操作的历史记录，在撤销时候用
*/
private List<Command> undoCmds = new ArrayList<Command>();

 

什么时候向命令的历史记录里面加值呢？
         很简单，答案是在每个操作按钮被按下的时候，也就是你操作加法按钮或者减法按钮的时候，示例代码如下

Java代码
  1.         public   void  addPressed(){  
  2.     this .addCmd.execute();  
  3.     //把操作记录到历史记录里面   
  4.     undoCmds.add(this .addCmd);  
  5. }  
  6. public   void  substractPressed(){  
  7.     this .substractCmd.execute();  
  8.     //把操作记录到历史记录里面   
  9.     undoCmds.add(this .substractCmd);  
  10. }   
        public void addPressed(){
		this.addCmd.execute();
		//把操作记录到历史记录里面
		undoCmds.add(this.addCmd);
	}
	public void substractPressed(){
		this.substractCmd.execute();
		//把操作记录到历史记录里面
		undoCmds.add(this.substractCmd);
	}

 

        然后在计算器类里面添加上一个撤销的按钮，如果它被按下，那么就从命令历史记录里取出最后一个命令来撤销，撤消完成后要把已经撤销的命令从历史记录里面删除掉，相当于没有执行过该命令了，示例代码如下：

Java代码
  1. public   void  undoPressed(){  
  2.     if ( this .undoCmds.size()> 0 ){  
  3.         //取出最后一个命令来撤销   
  4.         Command cmd = this .undoCmds.get( this .undoCmds.size()- 1 );  
  5.         cmd.undo();  
  6.         //然后把最后一个命令删除掉，   
  7.         this .undoCmds.remove(cmd);  
  8.     }else {  
  9.         System.out.println("很抱歉，没有可撤销的命令" );  
  10.     }  
  11. }   
public void undoPressed(){
	if(this.undoCmds.size()>0){
		//取出最后一个命令来撤销
		Command cmd = this.undoCmds.get(this.undoCmds.size()-1);
		cmd.undo();
		//然后把最后一个命令删除掉，
		this.undoCmds.remove(cmd);
	}else{
		System.out.println("很抱歉，没有可撤销的命令");
	}
}

 

        同样的方式，还可以实现恢复的功能，也为恢复设置一个可恢复的列表，需要恢复的时候从列表里面取最后一个命令进行重新执行就好了，示例代码如下：

Java代码
  1. /**  
  2. * 命令被撤销的历史记录，在恢复时候用  
  3. */   
  4. private  List<Command> redoCmds =  new  ArrayList<Command>();   
/**
* 命令被撤销的历史记录，在恢复时候用
*/
private List<Command> redoCmds = new ArrayList<Command>();

 

        那么什么时候向这个集合里面赋值呢？ 大家要注意，恢复的命令数据是来源于撤销的命令，也就是说有撤销才会有恢复，所以在撤销的时候向这个集合里面赋值，注意要在撤销的命令被删除前赋值。示例代码如下:

Java代码
  1. public   void  undoPressed(){  
  2.     if ( this .undoCmds.size()> 0 ){  
  3.         //取出最后一个命令来撤销   
  4.         Command cmd = this .undoCmds.get( this .undoCmds.size()- 1 );  
  5.         cmd.undo();  
  6.         <strong>//如果还有恢复的功能，那就把这个命令记录到恢复的历史记录里面   
  7.         this .redoCmds.add(cmd);</strong>  
  8.         //然后把最后一个命令删除掉，   
  9.         this .undoCmds.remove(cmd);  
  10.     }else {  
  11.         System.out.println("很抱歉，没有可撤销的命令" );  
  12.     }  
  13. }   
public void undoPressed(){
	if(this.undoCmds.size()>0){
		//取出最后一个命令来撤销
		Command cmd = this.undoCmds.get(this.undoCmds.size()-1);
		cmd.undo();
		//如果还有恢复的功能，那就把这个命令记录到恢复的历史记录里面
		this.redoCmds.add(cmd);

		//然后把最后一个命令删除掉，
		this.undoCmds.remove(cmd);
	}else{
		System.out.println("很抱歉，没有可撤销的命令");
	}
}

 

         那么如何实现恢复呢？请看示例代码：

Java代码
  1. public   void  redoPressed(){  
  2.     if ( this .redoCmds.size()> 0 ){  
  3.         //取出最后一个命令来重做   
  4.         Command cmd = this .redoCmds.get( this .redoCmds.size()- 1 );  
  5.         cmd.execute();        
  6.         <strong>//把这个命令记录到可撤销的历史记录里面   
  7.                       this .undoCmds.add(cmd);</strong>  
  8.         //然后把最后一个命令删除掉   
  9.         this .redoCmds.remove(cmd);  
  10.     }else {  
  11.         System.out.println("很抱歉，没有可恢复的命令" );  
  12.     }  
  13. }   
public void redoPressed(){
	if(this.redoCmds.size()>0){
		//取出最后一个命令来重做
		Command cmd = this.redoCmds.get(this.redoCmds.size()-1);
		cmd.execute();		
		//把这个命令记录到可撤销的历史记录里面
                      this.undoCmds.add(cmd);

		//然后把最后一个命令删除掉
		this.redoCmds.remove(cmd);
	}else{
		System.out.println("很抱歉，没有可恢复的命令");
	}
}

 

 好了，分步讲解了计算器类，一起来看看完整的计算器类的代码：

Java代码
  1. /**  
  2.  * 计算器类，计算器上有加法按钮、减法按钮，还有撤销和恢复的按钮  
  3.  */   
  4. public   class  Calculator {  
  5.     /**  
  6.      * 命令的操作的历史记录，在撤销时候用  
  7.      */   
  8.     private  List<Command> undoCmds =  new  ArrayList<Command>();  
  9.     /**  
  10.      * 命令被撤销的历史记录，在恢复时候用  
  11.      */   
  12.     private  List<Command> redoCmds =  new  ArrayList<Command>();  
  13.       
  14.     private  Command addCmd =  null ;  
  15.     private  Command substractCmd =  null ;  
  16.     public   void  setAddCmd(Command addCmd) {  
  17.         this .addCmd = addCmd;  
  18.     }  
  19.     public   void  setSubstractCmd(Command substractCmd) {  
  20.         this .substractCmd = substractCmd;  
  21.     }     
  22.     public   void  addPressed(){  
  23.         this .addCmd.execute();  
  24.         //把操作记录到历史记录里面   
  25.         undoCmds.add(this .addCmd);  
  26.     }  
  27.     public   void  substractPressed(){  
  28.         this .substractCmd.execute();  
  29.         //把操作记录到历史记录里面   
  30.         undoCmds.add(this .substractCmd);  
  31.     }  
  32.     public   void  undoPressed(){  
  33.         if ( this .undoCmds.size()> 0 ){  
  34.             //取出最后一个命令来撤销   
  35.             Command cmd = this .undoCmds.get(undoCmds.size()- 1 );  
  36.             cmd.undo();  
  37.             //如果还有恢复的功能，那就把这个命令记录到恢复的历史记录里面   
  38.             this .redoCmds.add(cmd );  
  39.             //然后把最后一个命令删除掉，   
  40.             this .undoCmds.remove(cmd);  
  41.         }else {  
  42.             System.out.println("很抱歉，没有可撤销的命令" );  
  43.         }  
  44.     }  
  45.     public   void  redoPressed(){  
  46.         if ( this .redoCmds.size()> 0 ){  
  47.             //取出最后一个命令来重做   
  48.             Command cmd = this .redoCmds.get(redoCmds.size()- 1 );  
  49.             cmd.execute();        
  50.             //把这个命令记录到可撤销的历史记录里面   
  51.             this .undoCmds.add(cmd);  
  52.             //然后把最后一个命令删除掉   
  53.             this .redoCmds.remove(cmd);  
  54.         }else {  
  55.             System.out.println("很抱歉，没有可恢复的命令" );  
  56.         }  
  57.     }  
  58. }   
/**
 * 计算器类，计算器上有加法按钮、减法按钮，还有撤销和恢复的按钮
 */
public class Calculator {
	/**
	 * 命令的操作的历史记录，在撤销时候用
	 */
	private List<Command> undoCmds = new ArrayList<Command>();
	/**
	 * 命令被撤销的历史记录，在恢复时候用
	 */
	private List<Command> redoCmds = new ArrayList<Command>();
	
	private Command addCmd = null;
	private Command substractCmd = null;
	public void setAddCmd(Command addCmd) {
		this.addCmd = addCmd;
	}
	public void setSubstractCmd(Command substractCmd) {
		this.substractCmd = substractCmd;
	}	
	public void addPressed(){
		this.addCmd.execute();
		//把操作记录到历史记录里面
		undoCmds.add(this.addCmd);
	}
	public void substractPressed(){
		this.substractCmd.execute();
		//把操作记录到历史记录里面
		undoCmds.add(this.substractCmd);
	}
	public void undoPressed(){
		if(this.undoCmds.size()>0){
			//取出最后一个命令来撤销
			Command cmd = this.undoCmds.get(undoCmds.size()-1);
			cmd.undo();
			//如果还有恢复的功能，那就把这个命令记录到恢复的历史记录里面
			this.redoCmds.add(cmd );
			//然后把最后一个命令删除掉，
			this.undoCmds.remove(cmd);
		}else{
			System.out.println("很抱歉，没有可撤销的命令");
		}
	}
	public void redoPressed(){
		if(this.redoCmds.size()>0){
			//取出最后一个命令来重做
			Command cmd = this.redoCmds.get(redoCmds.size()-1);
			cmd.execute();		
			//把这个命令记录到可撤销的历史记录里面
			this.undoCmds.add(cmd);
			//然后把最后一个命令删除掉
			this.redoCmds.remove(cmd);
		}else{
			System.out.println("很抱歉，没有可恢复的命令");
		}
	}
}

 

（5）终于到可以收获的时候了，写个客户端，组装好命令和接收者，然后操作几次命令，来测试一下撤销和恢复的功能，示例代码如下：

Java代码
  1. public   class  Client {  
  2.     public   static   void  main(String[] args) {  
  3.         //1：组装命令和接收者   
  4.         //创建接收者   
  5.         OperationApi operation = new  Operation();  
  6.         //创建命令对象，并组装命令和接收者   
  7.         AddCommand addCmd = new  AddCommand   (operation, 5 );  
  8.         SubstractCommand substractCmd =   
  9.                                     new  SubstractCommand(operation, 3 );  
  10.           
  11.         //2：把命令设置到持有者，就是计算器里面   
  12.         Calculator calculator = new  Calculator();  
  13.         calculator.setAddCmd(addCmd);  
  14.         calculator.setSubstractCmd(substractCmd);  
  15.           
  16.         //3:模拟按下按钮，测试一下   
  17.         calculator.addPressed();  
  18.         System.out.println("一次加法运算后的结果为："   
  19.                                      +operation.getResult());  
  20.         calculator.substractPressed();  
  21.         System.out.println("一次减法运算后的结果为："   
  22.                                      +operation.getResult());  
  23.           
  24.         //测试撤消   
  25.         calculator.undoPressed();  
  26.         System.out.println("撤销一次后的结果为："   
  27.                                      +operation.getResult());  
  28.         calculator.undoPressed();  
  29.         System.out.println("再撤销一次后的结果为："   
  30.                                      +operation.getResult());  
  31.           
  32.         //测试恢复   
  33.         calculator.redoPressed();  
  34.         System.out.println("恢复操作一次后的结果为："   
  35.                                      +operation.getResult());  
  36.         calculator.redoPressed();  
  37.         System.out.println("再恢复操作一次后的结果为："   
  38.                                      +operation.getResult());  
  39.     }  
  40. }   
public class Client {
	public static void main(String[] args) {
		//1：组装命令和接收者
		//创建接收者
		OperationApi operation = new Operation();
		//创建命令对象，并组装命令和接收者
		AddCommand addCmd = new AddCommand   (operation,5);
		SubstractCommand substractCmd = 
                                    new SubstractCommand(operation,3);
		
		//2：把命令设置到持有者，就是计算器里面
		Calculator calculator = new Calculator();
		calculator.setAddCmd(addCmd);
		calculator.setSubstractCmd(substractCmd);
		
		//3:模拟按下按钮，测试一下
		calculator.addPressed();
		System.out.println("一次加法运算后的结果为："
                                     +operation.getResult());
		calculator.substractPressed();
		System.out.println("一次减法运算后的结果为："
                                     +operation.getResult());
		
		//测试撤消
		calculator.undoPressed();
		System.out.println("撤销一次后的结果为："
                                     +operation.getResult());
		calculator.undoPressed();
		System.out.println("再撤销一次后的结果为："
                                     +operation.getResult());
		
		//测试恢复
		calculator.redoPressed();
		System.out.println("恢复操作一次后的结果为："
                                     +operation.getResult());
		calculator.redoPressed();
		System.out.println("再恢复操作一次后的结果为："
                                     +operation.getResult());
	}
}

 （6）运行一下，看看结果，享受一下可以撤销和恢复的操作，结果如下：

Java代码
  1. 一次加法运算后的结果为： 5   
  2. 一次减法运算后的结果为：2   
  3. 撤销一次后的结果为：5   
  4. 再撤销一次后的结果为：0   
  5. 恢复操作一次后的结果为：5   
  6. 再恢复操作一次后的结果为：2    
一次加法运算后的结果为：5
一次减法运算后的结果为：2
撤销一次后的结果为：5
再撤销一次后的结果为：0
恢复操作一次后的结果为：5
再恢复操作一次后的结果为：2

 

也就是初始值为0，执行的两次命令操作为先加上5，然后再减去3。看起来也很容易，对不。

 

 

未完待续......

转载自：http://chjavach.iteye.com/blog/711226

分享到：
| 研磨设计模式之命令模式-2(转)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    研磨设计模式-配套源代码 UTF-8格式

    《研磨设计模式》是一本深入探讨软件设计原则与实践的经典书籍，其配套源代码提供了丰富的实例，帮助读者更好地理解和应用各种设计模式。这个UTF-8格式的压缩包包含了书中介绍的各种设计模式的实现，是学习和研究...

    研磨设计模式(完整带书签).part2.pdf

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起，包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等，让读者能系统、完整、准确地掌握每个模式，...

    研磨设计模式--chjavach的博客文章

    研磨设计模式的过程是持续学习和实践的过程，chjavach的博客文章提供了深入探讨这些模式的宝贵资源，值得我们仔细阅读和学习。通过深入理解和运用这些设计模式，可以提升个人的编程技巧，同时也为团队合作和项目维护...

    研磨设计模式PDF

    《研磨设计模式》这本书是陈臣和王斌两位作者合作的成果，专注于讲解软件设计中的模式应用。设计模式是软件工程中的一种最佳实践，它总结了在特定上下文中解决问题的常见方法，使得开发者可以复用这些解决方案，提高...

    研磨设计模式博文集

    3. **行为型模式**：这一类模式主要关注对象间如何交互和分配职责，如策略模式（Strategy）、模板方法模式（Template Method）、观察者模式（Observer）、迭代器模式（Iterator）、命令模式（Command）、责任链模式...

    研磨设计模式.rar

    《研磨设计模式》这本书是软件开发领域中的经典之作，主要关注的是面向对象设计中的设计模式。设计模式是在特定上下文中解决常见问题的最佳实践，它为开发者提供了在类似情况下重复使用解决方案的模板，有助于提高...

    研磨设计模式-part3

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起，包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等，让读者能系统、完整、准确地掌握每个模式，...

    研磨设计模式(完整带书签).part1.pdf

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起，包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等，让读者能系统、完整、准确地掌握每个模式，...

    研磨设计模式 演示源代码

    "研磨设计模式 演示源代码"这个资源包含了对设计模式的详细解释和实例分析，旨在帮助学习者深入理解和应用这些模式。 1. **单例模式**：确保一个类只有一个实例，并提供一个全局访问点。在资源管理、缓存或者线程池...

    研磨设计模式-part2

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起，包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等，让读者能系统、完整、准确地掌握每个模式，...

    研磨设计模式-part4

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起，包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等，让读者能系统、完整、准确地掌握每个模式，...

    研磨设计模式视频课程PPT

    这个名为“研磨设计模式视频课程PPT”的压缩包包含了一份关于23种核心设计模式的详细教学资料，旨在帮助开发者提升软件设计的效率和可维护性。下面将对这些设计模式进行深入解析。 1. **单例模式（Singleton）**：...

    设计模式学习心得（研磨设计模式）

    这篇“设计模式学习心得（研磨设计模式）”博客及其相关的PDF文档，为我们提供了一个深入理解和应用设计模式的宝贵资源。以下将针对单例模式、工厂方法模式、策略模式、命令模式和桥接模式进行详细讲解。 1. **单例...

    X-gen PPT下载——《研磨设计模式》 实战

    《研磨设计模式》实战是IT领域中关于软件设计的一份重要资料，它主要探讨了设计模式在实际项目中的应用。设计模式是软件工程中经过长期实践总结出的通用问题解决方案，是解决常见设计问题的经验总结。这份PPT可能是...

    java 的研磨设计模式(模式)

    Java的研磨设计模式是将这些模式应用到Java编程中的具体体现，它能够帮助开发者编写出更加灵活、可维护和可扩展的代码。本篇文章将深入探讨设计模式的核心概念，并通过Java实例来解析这些模式。 1. 单例模式：确保...

    设计模式Golang实现《研磨设计模式》读书笔记.zip

    设计模式Golang实现《研磨设计模式》读书笔记Go语言设计模式Go语言设计模式的实例代码创建模式工厂简单模式（Simple Factory）工厂方法模式（工厂方法）抽象工厂模式（Abstract Factory）创建者模式（Builder）原型...

    研磨设计模式.part3（共4个）

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起，包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等，让读者能系统、完整、准确地掌握每个模式，...

    研磨设计模式.docx

    研磨设计模式系列包括单例模式、工厂方法模式、策略模式、命令模式和桥接模式等多种模式，每种模式都有其特点和应用场景。 单例模式 单例模式是一种创建型模式，用于限制一个类的实例化只能产生一个对象。单例模式...

    设计模式视频课程PPT

    "研磨设计模式视频课程PPT"是一套专门针对设计模式的学习资料，其目标是帮助开发者深入理解和应用这些模式。 本课程可能涵盖了以下主要的设计模式类别： 1. 创建型模式：这类模式涉及到对象的创建，如单例模式...

    研磨设计模式.part2（共4个）

    《研磨设计模式》完整覆盖GoF讲述的23个设计模式并加以细细研磨。初级内容从基本讲起，包括每个模式的定义、功能、思路、结构、基本实现、运行调用顺序、基本应用示例等，让读者能系统、完整、准确地掌握每个模式，...

Magicbox
Global site tag (gtag.js) - Google Analytics