[http://www.blogjava.net/supercrsky/articles/200497.html]

[http://xuzhenqinandy.iteye.com/blog/206011]

[http://www.linuxidc.com/Linux/2011-08/41686.htm]

[http://www.360doc.com/content/06/1127/10/5874_273854.shtml]

 

 命令模式有以下角色来组成            
1)  命令角色(Command):声明执行操作的接口。有java接口或者抽象类来实现。
2)  具体命令角色(Concrete Command):将一个接收者对象绑定于一个动作;调用接收者相应的操作,以实现命令角色声明的执行操作的接口。
3)  客户角色(Client):创建一个具体命令对象(并可以设定它的接收者)。
4)  请求者角色(Invoker):调用命令对象执行这个请求。
5)  接收者角色(Receiver):知道如何实施与执行一个请求相关的操作。任何类都可能作为一个接收者。

 

命令模式在SWING中经常用到,这种模式经常用在按钮上面。我现在把SWING中的这种模式提取出来供大家一起来讨论。

首先建立命令借口

Java代码
  1. public interface CommandInterface {   
  2.  public void excute();   
  3. }  
public interface CommandInterface {
 public void excute();
}


在建立两个不同的命令执行类

Java代码
  1. public class InCommand implements CommandInterface{   
  2.   
  3.  /**  
  4.   * 具体的命令执行内容  
  5.   */  
  6.  public void excute() {   
  7.   System.out.println("int command");   
  8.  }   
  9.   
  10. }   
  11.   
  12. public class OutCommand implements CommandInterface{   
  13.   
  14.  /**  
  15.   * 具体的命令执行内容  
  16.   */  
  17.  public void excute() {   
  18.   System.out.println("out command");   
  19.  }   
  20.   
  21. }  
public class InCommand implements CommandInterface{

 /**
  * 具体的命令执行内容
  */
 public void excute() {
  System.out.println("int command");
 }

}

public class OutCommand implements CommandInterface{

 /**
  * 具体的命令执行内容
  */
 public void excute() {
  System.out.println("out command");
 }

}


建立增加命令的借口

Java代码
  1. public interface AddCommandInterface {   
  2.  public void setCommand(CommandInterface comd);   
  3.  public CommandInterface getCommand();   
  4. }  
public interface AddCommandInterface {
 public void setCommand(CommandInterface comd);
 public CommandInterface getCommand();
}


增加命令的实现类

Java代码
  1. public class OutAddCommand implements AddCommandInterface{   
  2.   
  3.  private CommandInterface comd = null;   
  4.     
  5.  /**  
  6.   * 获得命令  
  7.   */  
  8.  public CommandInterface getCommand() {   
  9.      
  10.   return this.comd;   
  11.  }   
  12.   
  13.  /**  
  14.   * 设置命令  
  15.   */  
  16.  public void setCommand(CommandInterface comd) {   
  17.   this.comd = comd;   
  18.  }   
  19.   
  20. }  
public class OutAddCommand implements AddCommandInterface{

 private CommandInterface comd = null;
 
 /**
  * 获得命令
  */
 public CommandInterface getCommand() {
  
  return this.comd;
 }

 /**
  * 设置命令
  */
 public void setCommand(CommandInterface comd) {
  this.comd = comd;
 }

}



建立事件激发借口

Java代码
  1. public interface ActionInterface {   
  2.  public void actionPerformed(AddCommandInterface comInter);   
  3. }  
public interface ActionInterface {
 public void actionPerformed(AddCommandInterface comInter);
}



事件激发借口的实现类

Java代码
  1. public class ActionCommand implements ActionInterface{   
  2.  public void actionPerformed(AddCommandInterface comInter)   
  3.  {   
  4.   comInter.getCommand().excute();   
  5.  }   
  6. }  
public class ActionCommand implements ActionInterface{
 public void actionPerformed(AddCommandInterface comInter)
 {
  comInter.getCommand().excute();
 }
}


对命令接口的实现

Java代码
  1. public class Actualize {   
  2.     
  3.  private AddCommandInterface addCommand = null;   
  4.     
  5.  public Actualize()   
  6.  {   
  7.      
  8.  }   
  9.     
  10.  /**  
  11.   * 增加命令  
  12.   * @param addCommand  
  13.   */  
  14.  public void addCommandInter(AddCommandInterface addCommand)   
  15.  {   
  16.   this.addCommand = addCommand;   
  17.  }   
  18.     
  19.  /**  
  20.   * 执行命令  
  21.   * @param action  
  22.   */  
  23.  public void addAction(ActionInterface action)   
  24.  {   
  25.   action.actionPerformed(this.addCommand);   
  26.  }   
  27. }  
public class Actualize {
 
 private AddCommandInterface addCommand = null;
 
 public Actualize()
 {
  
 }
 
 /**
  * 增加命令
  * @param addCommand
  */
 public void addCommandInter(AddCommandInterface addCommand)
 {
  this.addCommand = addCommand;
 }
 
 /**
  * 执行命令
  * @param action
  */
 public void addAction(ActionInterface action)
 {
  action.actionPerformed(this.addCommand);
 }
}


封装接口的实现

Java代码
  1. public class ExcuteCommand {   
  2.  public static void exec(CommandInterface com) {   
  3.   Actualize actu = new Actualize();   
  4.      
  5.   OutAddCommand outAdd = new OutAddCommand();   
  6.      
  7.   outAdd.setCommand(com);   
  8.      
  9.   actu.addCommandInter(outAdd);   
  10.      
  11.   actu.addAction(new ActionCommand());   
  12.  }   
  13. }  
public class ExcuteCommand {
 public static void exec(CommandInterface com) {
  Actualize actu = new Actualize();
  
  OutAddCommand outAdd = new OutAddCommand();
  
  outAdd.setCommand(com);
  
  actu.addCommandInter(outAdd);
  
  actu.addAction(new ActionCommand());
 }
}


具体命令的调用

Java代码
  1. public class TestCommand {   
  2.  public static void main(String[] args)   
  3.  {   
  4.   OutCommand out = new OutCommand();   
  5.   ExcuteCommand.exec(out);   
  6.      
  7.   InCommand in = new InCommand();   
  8.   ExcuteCommand.exec(in);   
  9.  }   
  10. }  
public class TestCommand {
 public static void main(String[] args)
 {
  OutCommand out = new OutCommand();
  ExcuteCommand.exec(out);
  
  InCommand in = new InCommand();
  ExcuteCommand.exec(in);
 }
}


输出结果:

Java代码
  1. out command   
  2. int command  
out command
int command


 

Logo

更多推荐