如何在Java中管理状态更改 public void manage（） { 双速=getSpeedfromVehicle（）； 如果（速度>=0和速度10和速度=60） { System.out.println（“高速模式”）； } }

当车辆开始移动时，每次速度变化都会调用我的管理方法。

---

如果速度保持在一个类别（0到10）中，我只需要打印输出语句一次，即使对于速度0到10，manage（）调用了无限次。其他速度范围也应如此。它还应该切换到其他速度范围，并且应该只打印每个速度范围一次。

只需将一个

布尔值更新为实例变量，并在
if条件下更新
中的
布尔值

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

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");
        }

    }

公共级车速{
私有布尔慢；
私有布尔快速；
公共车速（）{
慢=假；
快速=错误；
}
公共静态void main（字符串[]args）{
.....
.....
}
公共空间管理（）
{
双速=getSpeedfromVehicle（）；
如果（速度>=0&&speed 10&&speed<60&&slow==false&&fast==false）
{
System.out.println（“中速模式”）；
}
否则，如果（速度>=60&fast==false）
{
System.out.println（“高速模式”）；
快速=正确；
}
}
}
您需要一个变量来检查当前速度模式的状态。我会考虑使用EnUM类和我的速度状态作为值。每次速度范围更改时，都会更新本地SpeedState枚举值，并在manage（）方法中对其进行验证

从我的头顶上看，它会像下面这样

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;
        }

    }


}

公共枚举状态{
低、中、高
}    
公务舱{
私营国家；
//支持代码、循环等
公共空间管理（）{
双速=getSpeedfromVehicle（）；
如果（（速度>=0和速度10和速度<60）和状态！=SpeedState.MEDIUM）
{
state=SpeedState.MEDIUM；
System.out.println（“中速模式”）；
}
如果（（速度>=60）和&state！=SpeedState.HIGH），则为else
{
state=SpeedState.HIGH；
System.out.println（“高速模式”）；
}
}
}
<代码> > p>我会考虑使用。然后为高、低和中设置一个状态。这样可以封装每个状态的行为。当您从一种状态转换到另一种状态时，可以对转换执行所需的操作。这是一个比循环更优雅的解决方案，并且更易于继续维护

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

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");
        }
    }
}

封装测试；
公车{
私人整数速度；
私人Speedo Speedo=新低速（）；
公共无效设置速度（整数速度）{
速度=速度；
}
public int getSpeed（）{
返回速度；
}
公共空间管理（）{
this.speedo=speedo.manage（速度）；
}
}
抽象类Speedo{
私有int低量程；
私人int高端；
私人Speedo lowState；
私人Speedo highState；
公共Speedo getLowState（）{
返回低状态；
}
公共Speedo getHighState（）{
返回高位状态；
}
public int getLowRange（）{
返回低量程；
}
公共无效设置下限（int下限）{
this.lowRange=低量程；
}
public int getHighRange（）{
返回高频段；
}
公共无效设置上限（整数上限）{
high.range=高量程；
}
公共抽象void onLowTransition（）；
公共抽象void onHighTransition（）；
公共Speedo管理（国际速度）{
如果（速度getHighRange（））{
onHighTransition（）；
返回getHighState（）；
}否则{
归还这个；
}
}
}
类低速扩展Speedo{
公共Speedo管理（国际速度）{
//TODO自动生成的方法存根
返回null；
}
@凌驾
public void onLowTransition（）{
//TODO自动生成的方法存根
}
@凌驾
public void onHighTransition（）{
//TODO自动生成的方法存根
}
}
中级速度扩展Speedo{
公共Speedo管理（国际速度）{
//TODO自动生成的方法存根
返回null；
}
@凌驾
public void onLowTransition（）{
//TODO自动生成的方法存根
}
@凌驾
public void onHighTransition（）{
//TODO自动生成的方法存根
}
}
等级高速扩展Speedo{
公共Speedo管理（国际速度）{
//TODO自动生成的方法存根
返回null；
}
@凌驾
public void onLowTransition（）{
//TODO自动生成的方法存根
}
@凌驾
public void onHighTransition（）{
//TODO自动生成的方法存根
}
}

这是不完整的，但它将为您提供一个很好的起点。
 < P>使用状态枚举变量来有条件地更新状态

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

    }
}

枚举速度模式{
低、中、高
};
私人速度模式速度模式；
公共空间管理（）{
双速=getSpeedfromVehicle（）；
如果（速度>=0和速度10和速度<60和速度模式！=speedMode.MEDIUM）{
speedMode=speedMode.MEDIUM；
System.out.println（“中速模式”）；
}否则如果（速度>=60&&speedMode！=speedMode.HIGH）{
speedMode=speedMode.HIGH；
System.out.println（“高速模式”）；
}
}
又是一个简单的例子：

公共级车速{

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");
    }

}

枚举速度{
慢（“慢”），中等(
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;
}

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

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);
        }

    }
}

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);
    }
}