精华内容
下载资源
问答
  • java 命令模式

    2019-06-10 03:38:34
    java 命令模式java 命令模式实例如下: java 命令模式 命令模式:将“请求“封装成对象,以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。 实例如下: interface Command { // ...

    java 命令模式

    命令模式:将“请求“封装成对象,以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

    实例如下:

    interface Command { // 命令
    	public void execute(); // 执行
    }
    class GarageDoor { // 车库门
    	public GarageDoor() {}
    	public void up() { System.out.println( "Garage Door is Open" ); }
    	public void down() { System.out.println( "Garage Door is Closed" ); }		
    	public void stop() { System.out.println( "Garage Door is Stopped" ); }
    	public void lightOn() { System.out.println( "Garage light is on" ); }	
    	public void lightOff() { System.out.println( "Garage light is off" ); }
    }
    class Light { // 电灯
    	public Light() {}	
    	public void on() { System.out.println( "Light is on" ); }
    	public void off() { System.out.println( "Light is off" ); }	
    }
    class GarageDoorOpenCommand implements Command { // 车库门打开命令
    	GarageDoor garageDoor;
    	public GarageDoorOpenCommand( GarageDoor garageDoor ) {
    		this.garageDoor = garageDoor;
    	}
    	public void execute() { garageDoor.up(); }
    }
    class LightOffCommand implements Command { // 熄灯命令
    	Light light; 
    	public LightOffCommand( Light light ) { this.light = light; } 
    	public void execute() { light.off(); }	
    }	
    class LightOnCommand implements Command { // 开灯命令
    	Light light;  
    	public LightOnCommand( Light light ) { this.light = light; }
    	public void execute() { light.on(); }	
    }
    class SimpleRemoteControl { // 简单遥控器
    	Command slot; // 命令插槽
    	public SimpleRemoteControl() {} 
    	public void setCommand( Command command ) { slot = command; }
    	public void buttonWasPressed() { slot.execute(); }	
    }
    class RemoteControlTest { // 遥控测试
    	public static void main( String[] args ) {
    		SimpleRemoteControl remote = new SimpleRemoteControl();
    		Light light = new Light();
    		GarageDoor garageDoor = new GarageDoor();
    		LightOnCommand lightOn = new LightOnCommand( light );
    		GarageDoorOpenCommand garageOpen = new GarageDoorOpenCommand( garageDoor ); 
    		remote.setCommand( lightOn );
    		remote.buttonWasPressed();
    		remote.setCommand( garageOpen );
    		remote.buttonWasPressed();
        }	
    }
    
    interface Command { public void execute(); }	
    class CeilingFan { // 吊扇
    	String location = "";
    	int level;
    	public static final int HIGH = 2;
    	public static final int MEDIUM = 1;
    	public static final int LOW = 0; 
    	public CeilingFan( String location ) { this.location = location; }
    	public void high() { // 高档
    		// turns the ceiling fan on to high
    		level = HIGH;
    		System.out.println( location + " ceiling fan is on high" ); 
    	} 
    	public void medium() { // 中档
    		// turns the ceiling fan on to medium
    		level = MEDIUM;
    		System.out.println( location + " ceiling fan is on medium" );
    	}
    	public void low() { // 低档
    		// turns the ceiling fan on to low
    		level = LOW;
    		System.out.println( location + " ceiling fan is on low" );
    	} 
    	public void off() { // 关掉
    		// turns the ceiling fan off
    		level = 0;
    		System.out.println( location + " ceiling fan is off" );
    	} 
    	public int getSpeed() { return level; } // 获取速度
    }
    class GarageDoor { // 车库门
    	String location;
    	public GarageDoor( String location ) { this.location = location; }
    	public void up() { System.out.println( location + " garage Door is Up" ); }
    	public void down() { System.out.println( location + " garage Door is Down" ); }
    	public void stop() { System.out.println( location + " garage Door is Stopped" ); }
    	public void lightOn() { System.out.println( location + " garage light is on" ); }
    	public void lightOff() { System.out.println( location + " garage light is off" ); }	
    }
    class Hottub { // 热浴缸
    	boolean on;
    	int temperature; // 温度
    	public Hottub() {}
    	public void on() { on = true; }
    	public void off() { on = false; }
    	public void bubblesOn() {
    		if ( on ) { System.out.println( "Hottub is bubbling!" ); } // 热水浴缸找开
    	}	
    	public void bubblesOff() {
    		if ( on ) { System.out.println( "Hottub is not bubbling" ); }	// 热水浴缸关掉	
    	}
    	public void jetsOn() {
    		if ( on ) { System.out.println( "Hottub jets are on" ); } // 热水浴缸喷头打开	
    	}
    	public void jetsOff() {
    		if ( on ) { System.out.println( "Hottub jets are off" ); } // 热水浴缸喷头关闭		
    	}
    	public void setTemperature( int temperature ) {
    		this.temperature = temperature;
    	}
    	public void heat() { // 加热
    		temperature = 105;
    		System.out.println( "Hottub is heating to a steaming 105 degrees" );
    	}
    	public void cool() { // 冷却
    		temperature = 98;
    		System.out.println( "Hottub is cooling to 98 degrees" );
    	}
    }
    class Light {
    	String location = "";
    	public Light( String location ) { this.location = location; }
    	public void on() { System.out.println( location + " light is on" ); }
    	public void off() { System.out.println( location + " light is off" ); }
    }
    class Stereo { // 立体音响
    	String location;
    	public Stereo( String location ) { this.location = location; }
    	public void on() { System.out.println( location + " stereo is on" ); }
    	public void off() { System.out.println( location + " stereo is off" ); }
    	public void setCD() { System.out.println( location + " stereo is set for CD input" ); }
    	public void setDVD() { System.out.println( location + " stereo is set for DVD input" ); }
    	public void setRadio() { System.out.println( location + " stereo is set for Radio" ); } // 收音机
    	public void setVolume( int volume ) { // 设置音量
    		// code to set the volume
    		// valid range: 1-11 ( after all 11 is better than 10, right? )
    		System.out.println( location + " Stereo volume set to " + volume );
    	}
    }
    class TV { // 电视
    	String location;
    	int channel; // 频道
    	public TV( String location ) { this.location = location; }
    	public void on() { System.out.println( "TV is on" ); }
    	public void off() { System.out.println( "TV is off" ); }
    	public void setInputChannel() { // 设置频道
    		this.channel = 3;
    		System.out.println( "Channel is set for VCR" ); // 录像机
    	}
    }
    class CeilingFanOffCommand implements Command { // 吊扇关闭命令
    	CeilingFan ceilingFan;
    	public CeilingFanOffCommand( CeilingFan ceilingFan ) {
    		this.ceilingFan = ceilingFan;
    	}
    	public void execute() { ceilingFan.off(); }
    }
    class CeilingFanOnCommand implements Command { // 吊扇打开命令
    	CeilingFan ceilingFan;
    	public CeilingFanOnCommand(CeilingFan ceilingFan ) {
    		this.ceilingFan = ceilingFan;
    	}
    	public void execute() { ceilingFan.high(); }
    }
    class GarageDoorDownCommand implements Command { // 车库门关闭命令
    	GarageDoor garageDoor;
    	public GarageDoorDownCommand( GarageDoor garageDoor) {
    		this.garageDoor = garageDoor;
    	}
    	public void execute() { garageDoor.down(); }
    }
    class GarageDoorUpCommand implements Command { // 车库门打开命令
    	GarageDoor garageDoor;
    	public GarageDoorUpCommand(GarageDoor garageDoor) {
    		this.garageDoor = garageDoor;
    	}
    	public void execute() { garageDoor.up(); }	
    }
    class HottubOffCommand implements Command { // 热管关闭命令
    	Hottub hottub;
    	public HottubOffCommand( Hottub hottub ) { this.hottub = hottub; }
    	public void execute() { hottub.cool(); hottub.off(); }
    }
    class HottubOnCommand implements Command { // 热管打开命令
    	Hottub hottub;
    	public HottubOnCommand( Hottub hottub ) { this.hottub = hottub; }
    	public void execute() {
    		hottub.on();
    		hottub.heat();
    		hottub.bubblesOn();
    	}
    }
    class LightOffCommand implements Command {  // 关灯命令
    	Light light; 
    	public LightOffCommand( Light light ) { this.light = light; }
    	public void execute() { light.off(); }
    }
    class LightOnCommand implements Command { // 开灯命令
    	Light light;
    	public LightOnCommand( Light light ) { this.light = light; }
    	public void execute() { light.on(); }
    }
    class LivingroomLightOffCommand implements Command { // 客厅灯光关闭命令
    	Light light;
    	public LivingroomLightOffCommand( Light light ) { this.light = light; }
    	public void execute() { light.off(); }
    }
    class LivingroomLightOnCommand implements Command { // // 客厅灯光打开命令
    	Light light;
    	public LivingroomLightOnCommand( Light light ) { this.light = light; }
    	public void execute() { light.on(); }
    }
    class NoCommand implements Command { // 无命令
    	public void execute() { }
    }
    class StereoOffCommand implements Command { // 音响关闭命令
    	Stereo stereo; 
    	public StereoOffCommand( Stereo stereo ) { this.stereo = stereo; }
    	public void execute() { stereo.off(); }
    }
    class StereoOnWithCDCommand implements Command { // 音响打开命令
    	Stereo stereo; 
    	public StereoOnWithCDCommand( Stereo stereo ) { this.stereo = stereo; }
    	public void execute() {
    		stereo.on();
    		stereo.setCD();
    		stereo.setVolume( 11 );
    	}
    }
    class RemoteControl { // 遥控
    	Command[] onCommands;
    	Command[] offCommands; 
    	public RemoteControl() {
    		onCommands = new Command[7];
    		offCommands = new Command[7]; 
    		Command noCommand = new NoCommand();
    		for ( int i = 0; i < 7; i ++ ) {
    			onCommands[i] = noCommand;
    			offCommands[i] = noCommand;
    		}
    	}  
    	public void setCommand( int slot, Command onCommand, Command offCommand ) {
    		onCommands[ slot ] = onCommand;
    		offCommands[ slot ] = offCommand;
    	} 
    	public void onButtonWasPushed( int slot ) {
    		onCommands[ slot ].execute();
    	} 
    	public void offButtonWasPushed( int slot ) {
    		offCommands[ slot ].execute();
    	}  
    	public String toString() {
    		StringBuffer stringBuff = new StringBuffer();
    		stringBuff.append( "\n------ Remote Control -------\n" );
    		for ( int i = 0; i < onCommands.length; i ++ ) {
    			stringBuff.append( "[slot " + i + "] " + onCommands[i].getClass().getName()
    				+ "    " + offCommands[i].getClass().getName() + "\n" );
    		}
    		return stringBuff.toString();
    	}
    }
    class RemoteLoader { // 遥控加载程序
    	public static void main( String[] args ) {
    		RemoteControl remoteControl = new RemoteControl(); 
    		Light livingRoomLight = new Light( "Living Room" );
    		Light kitchenLight = new Light( "Kitchen" );
    		CeilingFan ceilingFan= new CeilingFan( "Living Room" );
    		GarageDoor garageDoor = new GarageDoor( "" );
    		Stereo stereo = new Stereo( "Living Room" );  
    		LightOnCommand livingRoomLightOn = new LightOnCommand( livingRoomLight );				
    		LightOffCommand livingRoomLightOff = new LightOffCommand( livingRoomLight );				
    		LightOnCommand kitchenLightOn = new LightOnCommand( kitchenLight );				
    		LightOffCommand kitchenLightOff = new LightOffCommand( kitchenLight );
    		CeilingFanOnCommand ceilingFanOn = new CeilingFanOnCommand( ceilingFan );
    		CeilingFanOffCommand ceilingFanOff = new CeilingFanOffCommand( ceilingFan );
    		GarageDoorUpCommand garageDoorUp = new GarageDoorUpCommand( garageDoor );
    		GarageDoorDownCommand garageDoorDown = new GarageDoorDownCommand( garageDoor );
    		StereoOnWithCDCommand stereoOnWithCD = new StereoOnWithCDCommand( stereo );
    		StereoOffCommand  stereoOff = new StereoOffCommand( stereo );
    		remoteControl.setCommand( 0, livingRoomLightOn, livingRoomLightOff );
    		remoteControl.setCommand( 1, kitchenLightOn, kitchenLightOff );
    		remoteControl.setCommand( 2, ceilingFanOn, ceilingFanOff );
    		remoteControl.setCommand( 3, stereoOnWithCD, stereoOff );
    		System.out.println( remoteControl );
    		remoteControl.onButtonWasPushed( 0 );
    		remoteControl.offButtonWasPushed( 0 );
    		remoteControl.onButtonWasPushed( 1 );
    		remoteControl.offButtonWasPushed( 1 );
    		remoteControl.onButtonWasPushed( 2 );
    		remoteControl.offButtonWasPushed( 2 );
    		remoteControl.onButtonWasPushed( 3 );
    		remoteControl.offButtonWasPushed( 3 );
    	}
    }
    ----------------------------------------------------------
    E:\java>java Test0610
    
    ------ Remote Control -------
    [slot 0] LightOnCommand    LightOffCommand
    [slot 1] LightOnCommand    LightOffCommand
    [slot 2] CeilingFanOnCommand    CeilingFanOffCommand
    [slot 3] StereoOnWithCDCommand    StereoOffCommand
    [slot 4] NoCommand    NoCommand
    [slot 5] NoCommand    NoCommand
    [slot 6] NoCommand    NoCommand
    
    Living Room light is on
    Living Room light is off
    Kitchen light is on
    Kitchen light is off
    Living Room ceiling fan is on high
    Living Room ceiling fan is off
    Living Room stereo is on
    Living Room stereo is set for CD input
    Living Room Stereo volume set to 11
    Living Room stereo is off
    
    展开全文
  • JAVA命令模式

    千次阅读 2018-09-16 17:02:16
    JAVA命令模式 JAVA命令模式 前言: 1、命令模式的概念 2、命令模式的UML图及角色 3、命令模式的实现 4、命令模式的优点及缺点 5、命令模式使用场景 6、总结 前言: 今天是星期天,嗨皮了两天是时候开始...

    JAVA命令模式

    JAVA命令模式

    前言:

    1、命令模式的概念

    2、命令模式的UML图及角色

    3、命令模式的实现

    4、命令模式的优点及缺点

    5、命令模式使用场景

    6、总结


    前言:

    今天是星期天,嗨皮了两天是时候开始学习了!感觉要每天学一下,玩一下。这样感觉不会太无聊,但是了,学的时候又可能会想着玩,玩的时候又可能觉得还有事搞不定。麻烦,我果然是个婆婆妈妈,啰啰嗦嗦的男孩!哈哈,但是该学的时候还好是学习一波!

    今天要学习的是命令模式,我学设计模式有点拖泥带水啊!不过,说实在话的。设计模式只是让我脑海也一个大概的印象。我仍然认为所有的技术要在实际中接触到,然后思考,总结。才能够学会!毕竟,纸上得来终觉浅。闲话便说到这。

    命令模式给我的感受就是,开灯的开关。欸,我按一下开关,灯就开了,再按一下就关很听话!

    1、命令模式的概念

    命令模式;将一个请求封装为一个对象,从而可用不同的请求对客户进行参数化,对请求排队或者对请求做日志记录,以及可以支持撤销的操作。

    简而言之:命令模式可以将请求发送者和接受者进行解耦。通过,命令模式创建命令对象。命令对象接受,发送者的请求,然后命令对象调用对应的接受者的方法!

    2、命令模式的UML图及角色

     

    Command(抽象命令者):这个角色为接口或抽象类,其中生命的EXECUTE方法为调用请求接受者执行的方法。

    ConcreteCommand(具体命令者):这个角色实现了抽象命令类的方法,也是具体接受者的关联的类。同过具体的execute方法调用处理类的方法处理请求。

    Invoker(请求发送者):具体的请求发送者,不需要再创建的时候具体指定谁来处理它。可以再运行时通过命令对象具体注入谁来处理这个请求。

    Reciver(请求处理者):执行与请求相关的业务代码。

    3、命令模式的实现

    1、FunctionButton:作用为请求发送者角色。

    package commandPattern;
    /**
     * 
    * <p>Title: FunctionButton</p>  
    * <p>Description:按键调用者,     请求发送者 </p>  
    * @author HAND_WEILI  
    * @date 2018年9月16日
     */
    public class FunctionButton {
        private Command command;    //私有化命令对象
        /**
         * 注入命令对象
         * @param com
         */
        public void setCommand(Command com) {
            this.command=com;
        }
        
        public void click() {
            System.out.println("单击功能键");
            command.execute();
        }
        

    }
     

     

    2、Command:抽象命令类,这个核心类啊。

    package commandPattern;

    public  abstract class Command {
        public abstract void execute();

    }
     

     3、ExitCommand:具体角色类

    package commandPattern;

    public class ExitCommand extends Command {
        private SystemExitCommand sobj;
        
        public  ExitCommand() {
            // TODO Auto-generated constructor stub
            sobj=new SystemExitCommand();
        }
        @Override
        public void execute() {
            // TODO Auto-generated method stub
            //业务代码,该干活了
            sobj.exit();
        }

    }
     

    4、HelpCommand:具体命令类

    package commandPattern;

    public class HelpCommand extends Command {
        //关联帮助接受类
        private SystemHelpCommand sobj;
        public HelpCommand() {
            // TODO Auto-generated constructor stub
            sobj=new SystemHelpCommand();
        }
        @Override
        public void execute() {
            // TODO Auto-generated method stub
            sobj.help();
        }

    }
     

    5、SystemExitCommand :接受类

    package commandPattern;

    public class SystemExitCommand {

        public void exit() {
            // TODO Auto-generated method stub
            System.out.println("退出系统:");
        }

    }
     

     6、SystemHelpCommand:具体业务类.

    package commandPattern;

    public class SystemHelpCommand {

        public void help() {
            // TODO Auto-generated method stub
            System.out.println("帮助你,是我的责任MONSTER");
        }

    }
     

     

    7、

    package commandPattern;

    import java.io.File;
    import java.io.IOException;

    import javax.xml.parsers.*;

    import org.w3c.dom.*;

    public class XMLUtils {
        public static Object getCommandClass() {
            //第一步获取xmL文件
            
            try {
                DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
                DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
                Document doc;
                doc=dBuilder.parse(new File("src//commandPattern//config.xml"));
                
                
                
                //同过文档获得对应的类型.
                NodeList list = doc.getElementsByTagName("className");
                Node node =list.item(0).getFirstChild();
                String className =    node.getNodeValue();
                Object obj = Class.forName(className).newInstance();
                return obj;
            } catch (Exception e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            } 
            
            
            return null;
            
        }

    }

     

     8、config.xml

    <?xml version="1.0" ?>
    <config>
        <className>commandPattern.ExitCommand</className>
    </config>

     9、Client。

    package commandPattern;

    public class Client {
        public static void main(String[] args) {
            FunctionButton f1=new FunctionButton();
            Command c1;
            c1=(ExitCommand) XMLUtils.getCommandClass();
            f1.setCommand(c1);
            f1.click();
            
            
        }
    }
     

    4、命令模式的优点及缺点

    优点:

    1. 命令模式可以解耦对应的发送者和接受者之间的联系。通过命令对象来进行接收者的调配。
    2. 可以容易的设计一个宏命令。

    缺点:

         1、会可能出现很多个具体的命令类。造成系统的冗余。

     

    5、命令模式使用场景

          1、系统需要将请求调用者和请求接受者进行解耦,使得使用者和调用者互相解耦。请求调用者无需知道请求接受者的存在。

          2、系统需要再不同的时间指定请求,将请求排队执行。

          3、系统需要支持命令的撤销操作和恢复操作。

    6、总结

    • 命令模式还有其他应用场景,可以和组合模式相配合。可以和做成宏命令,不过这些,我还没切身体验,先留个概念。
    • 命令模式是行为型的设计模式。
    • 钱,真的很重要。

     

    展开全文
  • Java命令模式

    2017-07-05 14:31:05
    Java命令模式 命令模式是数据驱动设计模式,属于行为模式类别。 请求作为命令包装在一个对象下,并传递给调用器对象。 调用者对象查找可以处理此命令的适当对象,并将命令传递到执行命令的相应对象。 实现...
    Java命令模式


    命令模式是数据驱动设计模式,属于行为模式类别。 请求作为命令包装在一个对象下,并传递给调用器对象。 调用者对象查找可以处理此命令的适当对象,并将命令传递到执行命令的相应对象。


    实现实例


    在这个示例中,创建了一个作为命令的接口- Order,同时也创建了一个Stock类作为请求。 有具体的命令类BuyStock和SellStock实现Order接口将做实际的命令处理。 将创建一个类Broker作为调用器对象。它可以接收和下订单。


    Broker对象使用命令模式来标识哪个对象,并根据命令类型执行哪个命令。 CommandPatternDemo这是一个演示入口类,将使用Broker类演示命令模式。




    第1步


    创建一个命令接口。实现代码如下所示 -


    Order.java




     
    public interface Order {
       void execute();
    }
    Java
    第2步


    创建一个请求对象
    Stock.java


    public class Stock {


       private String name = "ABC";
       private int quantity = 10;


       public void buy(){
          System.out.println("Stock [ Name: "+name+", 
             Quantity: " + quantity +" ] bought");
       }
       public void sell(){
          System.out.println("Stock [ Name: "+name+", 
             Quantity: " + quantity +" ] sold");
       }
    }
    Java
    第3步


    创建实现Order接口的具体类。


    BuyStock.java




    public class BuyStock implements Order {
       private Stock abcStock;


       public BuyStock(Stock abcStock){
          this.abcStock = abcStock;
       }


       public void execute() {
          abcStock.buy();
       }
    }
    Java
    SellStock.java


    public class SellStock implements Order {
       private Stock abcStock;


       public SellStock(Stock abcStock){
          this.abcStock = abcStock;
       }


       public void execute() {
          abcStock.sell();
       }
    }
    Java
    第4步


    创建命令调用程序类。
    Broker.java


    import java.util.ArrayList;
    import java.util.List;


       public class Broker {
       private List<Order> orderList = new ArrayList<Order>(); 


       public void takeOrder(Order order){
          orderList.add(order);        
       }


       public void placeOrders(){


          for (Order order : orderList) {
             order.execute();
          }
          orderList.clear();
       }
    }
    Java
    第5步


    使用Broker类来接收和执行命令。
    CommandPatternDemo.java




    public class CommandPatternDemo {
       public static void main(String[] args) {
          Stock abcStock = new Stock();


          BuyStock buyStockOrder = new BuyStock(abcStock);
          SellStock sellStockOrder = new SellStock(abcStock);


          Broker broker = new Broker();
          broker.takeOrder(buyStockOrder);
          broker.takeOrder(sellStockOrder);


          broker.placeOrders();
       }
    }
    Java
    第6步


    验证输出,执行上面的代码得到以下结果 -


    Stock [ Name: ABC, Quantity: 10 ] bought
    Stock [ Name: ABC, Quantity: 10 ] sold
    展开全文
  • Java 命令模式

    2015-05-13 19:48:23
    Java命令模式Java命令模式是将“请求”封装成对象,以便使用不同的请求。 Invoker是调用者对象相当于遥控器,Invoker和Receiver(Receiver相当于一个提供设备的一方,比如:电灯,电灯有开和关的命令)之间通过...

    Java命令模式,Java命令模式是将“请求”封装成对象,以便使用不同的请求。


    Invoker是调用者对象相当于遥控器,Invoker和Receiver(Receiver相当于一个提供设备的一方,比如:电灯,电灯有开和关的命令)之间通过Command接口进行解耦,ConcreteCommand实现Command接口,里面接收Receiver的对象实现相应的操作。

    命令模式,还可以在请求队列、连接池、日志和支持撤销的操作中使用,请求者的请求可以放在队列中,由另外的线程取走执行。

    <pre name="code" class="java">public interface Command{
    	public void execute();
    	public void undo();
    }

    public class Invoker{//相当于遥控器
    	
    	//List<Command> cList = new LinkedList<Command>();
    	Command[] onCommand= new Command[4];
    	Command[] offCommand= new Command[4];
    	
    	public void set(int num,Command c1,Command c2){
    		if(num<4&&num>=0){
    		onCommand[num] = c1;
    		offCommand[num]=c2;
    		}
    		else System.out.println("遥控器按钮受限!");
    	}
    	
    	public void on(int num){
    		if(num<4&&num>=0)
    			onCommand[num].execute();
    			else System.out.println("不支持此命令:"+num);
    	}
    	
    	public void off(int num){
    		if(num<4&&num>=0)
    			offCommand[num].execute();
    			else System.out.println("不支持此命令:"+num);
    	}
    	
    }

    
    
    </pre><pre>
    public class Light{
    
    public void lightOn(){
    System.out.println("---The light is on!");
    }
    
    public void lightOff(){
    System.out.println("---The light is off!");
    }
    }



    public class LightOff implements Command{
    
    
    Light light;
    
    public LightOff(Light light){
    this.light = light;
    }
    
    public void execute(){
    light.lightOff();
    }
    
    public void undo(){
    light.lightOn();
    }
    
    
    }





    public class LightOn implements Command{
    
    Light light;
    
    public LightOn(Light light){
    this.light = light;
    }
    
    public void execute(){
    light.lightOn();
    }
    
    public void undo(){
    light.lightOff();
    }
    }
    
    public class NoCommand implements Command{
    
    
    @Override
    public void execute() {
    // TODO Auto-generated method stub
    
    }
    
    
    @Override
    public void undo() {
    // TODO Auto-generated method stub
    
    }
    
    
    }
    
    public class User {
    
    
    /**
    * @param args
    */
    public static void main(String[] args) {
    
    Light light =new Light();
    
    //电灯的关和开
    LightOn lightOn = new LightOn(light);
    LightOff lightOff = new LightOff(light);
    //空命令
    NoCommand noCommand = new NoCommand();
    
    Invoker control = new Invoker();//遥控器
    
    control.set(0,lightOn,lightOff);
    control.set(1,noCommand,noCommand);
    
    //执行遥控器上面的操作
    
    control.on(0);//开电灯
    control.off(0);//关电灯
    
    control.on(1);//开电灯
    control.off(1);//关电灯
    
    }
    
    
    }
    


    展开全文
  • java命令模式

    2015-03-25 21:18:51
    java命令模式 意图:将一个请求封装为一个对象,从而可用不同的请求对客户进行参数化;对请求排队或记录日志,以及支持可撤销的操作 动机:将”发出请求的对象”和”接收与执行这些请求的对象”分隔开来。 效果:...
  • JAVA 命令模式

    2020-05-19 10:50:14
    命令模式设计模式属于行为型模式,将一个请求封装成一个对象,从而让你使用不同的请求把客户端参数化,对请求排队或者记录请求日志,可以提供命令的撤销和恢复功能。 特点 优点:消除了请求发送者和具体指定接收者...
  • 本篇文章帮大家学习java命令模式,包含了Java命令模式使用方法、操作技巧、实例演示和注意事项,有一定的学习价值,大家可以用来参考。命令模式是数据驱动设计模式,属于行为模式类别。 请求作为命令包装在一个对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,236
精华内容 2,494
关键字:

java命令模式

java 订阅