2 
public void manage()
    {
        double speed = getSpeedfromVehicle();

        if(speed >=0 && speed <= 10)
        {
            System.out.println("Low Speed mode");
        }
        else if(speed > 10 && speed < 60)
        {
            System.out.println("Medium Speed Mode");
        }
        else if(speed >= 60)
        {
            System.out.println("High Speed Mode");
        }

    }

当车辆开始移动时，每次速度变化都会调用我的管理方法。如果速度保持在一个类别（0 到 10）中，我只需要打印一次输出语句，即使很难，对于速度 0 到 10，manage() 也会被无限次调用。这也应该发生在其他速度范围内。它还应该切换到其他速度范围，并且每个速度范围只打印一次。

4

7 回答 7

6

您需要有一个变量来检查当前速度模式的状态。我会考虑使用以我的速度状态为值的枚举类。每次速度范围发生变化时，您都会更新本地 SpeedState 枚举值并在 manage() 方法中对其进行验证。

在我的脑海中，它看起来像以下......

public enum SpeedState {
    LOW, MEDIUM, HIGH
}    


public class Drive{
    private SpeedState state;

    // Supporting code, loops, etc

    public void manage(){
        double speed = getSpeedfromVehicle();

        if((speed >=0 && speed <= 10) && state != SpeedState.LOW)
        {
           state = SpeedState.LOW;
           System.out.println("Low Speed mode");
        }
        else if((speed > 10 && speed < 60) && state != SpeedState.MEDIUM)
        {
           state = SpeedState.MEDIUM;
           System.out.println("Medium Speed Mode");
        }
        else if((speed >= 60) && state != SpeedState.HIGH)
        {
           state = SpeedState.HIGH;
           System.out.println("High Speed Mode");
        }
    }
}
于 2013-09-12T13:18:43.717 回答
1

我会考虑使用State 模式。然后有一个高、低和中的状态。这样您就可以封装每个状态的行为。当您从一种状态转换到另一种状态时，您可以在转换时执行所需的操作。这是一个比循环更优雅的解决方案，并且更容易维护。

下面是一个示例，说明如何使用状态模式来管理汽车在速度方面的状态。

package test;

public class Car {

    private int speed;
    private Speedo speedo = new LowSpeed();

    public void setSpeed(int speed) {
        this.speed = speed;
    }

    public int getSpeed() {
        return speed;
    }

    public void manage() {
        this.speedo = speedo.manage(speed);
    }

}

abstract class Speedo {
    private int lowRange;
    private int highRange;
    private Speedo lowState;
    private Speedo highState;

    public Speedo getLowState() {
        return lowState;
    }

    public Speedo getHighState() {
        return highState;
    }

    public int getLowRange() {
        return lowRange;
    }

    public void setLowRange(int lowRange) {
        this.lowRange = lowRange;
    }

    public int getHighRange() {
        return highRange;
    }

    public void setHighRange(int highRange) {
        this.highRange = highRange;
    }

    public abstract void onLowTransition();

    public abstract void onHighTransition();

    public Speedo manage(int speed) {
        if (speed < getLowRange()) {
            onLowTransition();
            return getLowState();
        } else if (speed > getHighRange()) {
            onHighTransition();
            return getHighState();
        } else {
            return this;
        }
    }
}

class LowSpeed extends Speedo {

    public Speedo manage(int speed) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void onLowTransition() {
        // TODO Auto-generated method stub

    }

    @Override
    public void onHighTransition() {
        // TODO Auto-generated method stub

    }
}

class MidSpeed extends Speedo {

    public Speedo manage(int speed) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void onLowTransition() {
        // TODO Auto-generated method stub

    }

    @Override
    public void onHighTransition() {
        // TODO Auto-generated method stub

    }
}

class HighSpeed extends Speedo {

    public Speedo manage(int speed) {
        // TODO Auto-generated method stub
        return null;
    }

    @Override
    public void onLowTransition() {
        // TODO Auto-generated method stub

    }

    @Override
    public void onHighTransition() {
        // TODO Auto-generated method stub

    }
}

这是不完整的，但它会给你一个很好的基础。

于 2013-09-12T13:24:06.587 回答
0

只需将 aboolean isUpdated作为您的实例变量并更新boolean.if condition

在打印语句之前，只需检查布尔值是真还是假。

public class CarSpeed{

    private boolean slow;
    private boolean fast;

    public CarSpeed(){
         slow = false;
         fast = false;
    }

    public static void main(String[] args){
        .....
        .....
    }

    public void manage()
    {
        double speed = getSpeedfromVehicle();

        if(speed >=0 && speed <= 10 && slow == false)
        {
            System.out.println("Low Speed mode");
            slow = true;
        }
        else if(speed > 10 && speed < 60 && slow == false && fast == false)
        {
            System.out.println("Medium Speed Mode");
        }
        else if(speed >= 60 & fast == false)
        {
            System.out.println("High Speed Mode");
            fast = true;
        }

    }


}
于 2013-09-12T13:13:52.750 回答
0

如果您使用以下解决方案之一：

if((speed >=0 && speed <= 10) && state != SpeedState.LOW)
...
else if((speed > 10 && speed < 60) && state != SpeedState.MEDIUM)
...
else if((speed >= 60) && state != SpeedState.HIGH)
...

那么请不要因为这段代码做了太多的比较。例如：如果当前状态是LOW，当前速度是，5那么第一个条件((speed >=0 && speed <= 10) && state != SpeedState.LOW)将返回false，但是，因为else if它也会检查其他条件，但是为了什么呢？我们已经知道速度必须是LOW，不需要做其他检查。

所以这里有一个更好的版本：

public enum SpeedState {
    LOW, MEDIUM, HIGH
}

public class Drive {
    private SpeedState state;

    public void manage() {
        double speed = getSpeedfromVehicle();

        SpeedState newState = null;

        if (speed >= 0 && speed <= 10)
            newState = SpeedState.LOW;
        else if (speed > 10 && speed < 60)
            newState = SpeedState.MEDIUM;
        else if (speed >= 60)
            newState = SpeedState.HIGH;

        if (newState != state) {
            state = newState;
            System.out.println("State changed to" + state);
        }

    }
}
于 2013-09-12T13:46:06.927 回答
0

还有一个简单的例子：

公共类 CarSpeed {

enum Speed {
    SLOW("Slow"),MEDIUM("Medium"),FAST("Fast");
    String speedString;
    Speed(String speedString) {
        this.speedString = speedString;
    }
    static Speed getCurrentSpeed(double currentSpeed) {
        if (currentSpeed <= 10)
            return SLOW;
        else if (currentSpeed >10 && currentSpeed <= 60)
            return MEDIUM;
        else
            return FAST;
    }
    String getSpeedString() {
        return speedString;
    }
}

private Speed currentSpeed = Speed.SLOW; 


public void manage() {
    Speed newSpeed = Speed.getCurrentSpeed(getSpeedfromVehicle());

    if (currentSpeed != newSpeed) {
        currentSpeed = newSpeed;
        System.out.println("It's now going " + currentSpeed.getSpeedString() + "!");
    }

}

double speed;
public double getSpeedfromVehicle() {
    return speed;
}
public void setSpeedfromVehicle(double speed) {
    this.speed = speed;
}

}

于 2013-09-12T13:38:52.987 回答
0

如果您的速度具有整数增量，则在枚举对象中还有另一种具有预定义速度范围的解决方案。在双倍速度变化的情况下 11 到 10、61 到 60 并检查最小值作为排他值。

public enum SpeedMode {
    LOW(0, 10), MEDIUM(11, 60), HIGH(61, 300);

    private final int minSpeed;
    private final int maxSpeed;

    SpeedMode(int minSpeed, int maxSpeed) {
        this.minSpeed = minSpeed;
        this.maxSpeed = maxSpeed;
    }

    public int getMinSpeed() {
        return this.minSpeed;
    }

    public int getMaxSpeed() {
        return this.maxSpeed;
    }

}

public class SpeedSelector {
    private SpeedMode speedMode;
    private boolean speedChanged;

    public SpeedSelector() {
        this.speedMode = SpeedMode.LOW;
        this.speedChanged = true;
    }

    public void change(int speed) {
        boolean validSpeed = false;

        for (SpeedMode speedMode : SpeedMode.values()) {
            if (speedMode.getMinSpeed() <= speed
                    && speed <= speedMode.getMaxSpeed()) {
                            validSpeed = true;
                if (this.speedMode != speedMode) {
                    speedChanged = true;
                    this.speedMode = speedMode;
                    break;
                }
            }
        }

        if (!validSpeed)
            throw new IllegalArgumentException("Invalid speed range");
    }

    public SpeedMode getSpeedMode() {
        return speedMode;
    }

    @Override
    public String toString() {
        if (speedChanged) {
            speedChanged = false;
            return "Speed changed to " + speedMode.name();
        } else
            return "";
    }

}

public class TestClass {
    public static void main(String[] args) {
        SpeedSelector speedSelector = new SpeedSelector();
        System.out.println(speedSelector);
        speedSelector.change(23);
        System.out.println(speedSelector);
        speedSelector.change(25);
        System.out.println(speedSelector);
        speedSelector.change(100);
        System.out.println(speedSelector);
        speedSelector.change(150);
        System.out.println(speedSelector);
        speedSelector.change(10);
        System.out.println(speedSelector);
    }
}
于 2013-09-12T13:49:52.427 回答
0

使用 State 枚举变量有条件地更新状态

enum SpeedMode {
    LOW, MEDIUM, HIGH
};

private SpeedMode speedMode;

public void manage() {
    double speed = getSpeedfromVehicle();

    if (speed >= 0 && speed <= 10 && speedMode!=SpeedMode.LOW) {
        speedMode=SpeedMode.LOW;
        System.out.println("Low Speed mode");
    } else if (speed > 10 && speed < 60 && speedMode!=SpeedMode.MEDIUM) {
        speedMode=SpeedMode.MEDIUM;
        System.out.println("Medium Speed Mode");
    } else if (speed >= 60 && speedMode!=SpeedMode.HIGH) {
        speedMode=SpeedMode.HIGH;
        System.out.println("High Speed Mode");
    }

}
于 2013-09-12T13:29:20.217 回答