Question

如何创建一个类来捕获具有不同参数类型的命令？捕获具有类似参数类型的命令以通过摆动来操作门对象，例如， (Swing, DoorNo, swingAngle)，我按如下方式创建一个类;

class DoorCommand {
     private String commandName;
     private int doorNo;
     private float swingAngle;

     public DoorCommand (String cmdName, int doorNo, float swing angle) {
        // set values here
     }

     // do all the setter and getter here
}

我的问题是，我需要使用(Lock, ENABLE/DISABLE)作为参数启用和禁用门锁。我如何在DoorCommand班级中容纳这个？我希望能够将DoorCommands存储在列表中; List<DoorCommand> doorCommands = new ArrayList<DoorCommand>();

Answer 1

为什么不提取门命令的界面，比如IDoorCommand？

然后从您的示例中创建DoorCommand来实现它（我会将名称更改为更相关，例如SwingDoorCommand）。

然后添加另一个命令，实现IDoorCommand，说DoorLockControlCommand关闭/打开锁定，具体取决于构造函数参数。

通过这种方式，您可以在List<IDoorCommand>中存储这两种类型的命令，并在不需要知道详细信息的情况下调用它们。

希望这能回答你的问题。

Answer 2

您可能想要查看Command Pattern，它允许您将每个命令创建为公共接口的子类，因此将命令存储在列表中以用于历史或撤消目的。在你的情况下：

// The basic interface for all door commands
public interface DoorCommand {
    public void execute(Door door) throws CommandException;
}

// The Door class is the recipient for all commands
public class Door {
    private List<Command> history = new ArrayList<Command>();
    private int angle;
    private boolean locked;

    public void addCommandToHistory(Command command) {
        history.add(command);
    }

    // Getters and setters.
}

// The command to open the door
public class OpenDoor implements DoorCommand {
    public void execute(Door door) throws CommandException {
        door.addCommandToHistory(this);
        if (door.isLocked()) {
            throw new CommandException("Door is locked, cannot open");
        }
        if (door.getAngle() < 90) {
            door.setAngle(90);
        }
    }
}

// Another command, LockDoor
public class LockDoor implements DoorCommand {
    public void execute(Door door) throws CommandException {
        door.addCommandToHistory(this);
        door.setLocked(true);
    }
}

然后你可以使用这样的命令：

public void operateDoor() {
    Door door = new Door();
    new LockDoor().execute(door);
    new OpenDoor().execute(door);
}

或者，您可以使用构造函数将Door对象传递给命令。

Answer 3

我不确定我是否理解你的问题。在我看来，你的命令只是存储操作的信息，它们不在门上操作，例如，更改门的实例变量等，对吗？如果您愿意更改此内容，则可以使用Command Pattern。也许这已经是你的计划了。然后，命令在执行时必须考虑Door的状态。

Answer 4

使用访客模式。

您的命令有一个方法接受Door并对其采取行动。

您循环遍历DoorCommand个对象并向每个对象发送Door，它会按照自己的意愿执行。

这样，您的DoorCommand逻辑与Door分开，而且您不需要一个庞大的DoorCommand类来实现所有可能的命令。

这是一个简单的例子：

static class Door {

    private final String name;

    public Door(String name) {
        this.name = name;
    }

    public void accept(final DoorVisitor visitor) {
        visitor.visit(this);
    }

    @Override
    public String toString() {
        return name;
    }
}

static interface DoorVisitor {

    void visit(Door door);
}

static class SwingCommand implements DoorVisitor {

    private final float swingAngle;

    public SwingCommand(float swingAngle) {
        this.swingAngle = swingAngle;
    }

    @Override
    public void visit(Door door) {
        System.out.printf("Swing door %s by %s%n", door, swingAngle);
    }
}

static class LockCommand implements DoorVisitor {

    private boolean locked;

    public LockCommand(boolean locked) {
        this.locked = locked;
    }

    @Override
    public void visit(Door door) {
        System.out.printf("Door %s is locked: %s%n", door, locked);
    }
}

public static void main(String[] args) throws Exception {
    final Door door = new Door("Front Door");
    final List<DoorVisitor> commands = new LinkedList<>();
    commands.add(new SwingCommand(0));
    commands.add(new LockCommand(true));
    for (final DoorVisitor c : commands) {
        door.accept(c);
    }
}

Answer 5

使用 polymorphism 使用类似的东西。

public class DoorCommand {
    private String cmdName;
    private static List<DoorCommand> list;

    static interface DoorCommandBase {
        void doAction(Object... arg);
    }

    class SwingCommand implements DoorCommandBase {
        void doAction(Object... arg) {
            int doorNo;
            float swingAngle;

            cmdName = arg[0];
            doorNo = arg[1];
            swingAngle = arg[2];
            // action to be performed
            updateList(arg);
        }
    }

    class LockCommand implements DoorCommandBase {
        void doAction(Object... arg) {
            boolean istrue;

            cmdName = arg[0];
            istrue = arg[1];
            // action to be performed
            updateList(arg);
        }
    }

    public static void updateList(Object... arg) {
        // update list
    }

    // getters and setters
}

如何创建一个类来捕获具有不同参数类型的用户输入？

5 个答案: