java密钥侦听器问题真的很新

简单的问题，基本上谁能告诉我怎么做，当我在java中按下一个“said”键时，它会执行和我按住它时相同的任务。例如，当我单击一个键时，他移动了一定的距离，但他移动的距离与我按住键的时间成正比。我需要的是，即使我按下它0.5秒或20秒，它也会走相同的距离

基本上，这是主类中的关键事件（用于记录用户输入）

这是背景根据我设置的移动速度滚动的部分

//Scrolls Background accordingly.
    if (speedX < 0) {
        centerX += speedX;
    }
    if (speedX == 0 || speedX < 0) {
        bg1.setSpeedX(0);
        bg2.setSpeedX(0);

    }
    if (centerX <= 200 && speedX > 0) {
        centerX += speedX;
    }
    if (speedX > 0 && centerX > 200) {
        bg1.setSpeedX(-getMOVESPEED());
        bg2.setSpeedX(-getMOVESPEED());
    }

导入java.awt.Rectangle； 导入java.awt.Graphics

公级骑士{

final int JUMPSPEED = -15;
private int MOVESPEED = 5;
final int GROUND = 202;
private int centerX = 350;
private int centerY = GROUND;
private boolean jumped = false;
private boolean movingLeft = false;
private boolean movingRight = false;
private boolean ducked = false;

private static Background bg1 = Main.getBg1();                 
private static Background bg2 = Main.getBg2();

private int speedX = 0;
private int speedY = 0;


public void update() {

    // Moves Character or Scrolls Background accordingly.
    if (speedX < 0) {
        centerX += speedX;
    }
    if (speedX == 0 || speedX < 0) {
        bg1.setSpeedX(0);
        bg2.setSpeedX(0);

    }
    if (centerX <= 200 && speedX > 0) {
        centerX += speedX;
    }
    if (speedX > 0 && centerX > 200) {
        bg1.setSpeedX(-getMOVESPEED());
        bg2.setSpeedX(-getMOVESPEED());
    }

    // Updates Y Position

    if (centerY + speedY >= 202) {
        centerY = 202;
    }else{                        
                    centerY += speedY;
            }

    // Handles Jumping
    if (jumped == true) {
        speedY += 1;

        if (centerY + speedY >= 202) {
            centerY = 202;
            speedY = 0;
            jumped = false;
        }

    }

    // Prevents going beyond X coordinate of 0
    if (centerX + speedX <= 60) {
        centerX = 61;
    }
}

 public void moveRight() {
        if (ducked == false) {

        speedX = MOVESPEED;

   if (MOVESPEED >= 5){
       MOVESPEED ++;

   }

   if (MOVESPEED >= 7 ){
       MOVESPEED = 0;
   }




        }
    }

    public void moveLeft() {
        if (ducked == false) {
            speedX = -getMOVESPEED();
        }
    }

    public void stopRight() {
        setMovingRight(false);
        stop();
    }

    public void stopLeft() {
        setMovingLeft(false);
        stop();
    }

    public void stop() {
        if (isMovingRight() == false && isMovingLeft() == false) {
            speedX = 0;
        }

        if (isMovingRight() == false && isMovingLeft() == true) {
            moveLeft();
        }

        if (isMovingRight() == true && isMovingLeft() == false) {
            moveRight();
        }

    }

    public void jump() {
        if (jumped == false) {
            speedY = JUMPSPEED;
            jumped = true;
        }

    }

public int getCenterX() {
    return centerX;
}

public int getCenterY() {
    return centerY;
}

public boolean isJumped() {
    return jumped;
}

public int getSpeedX() {
    return speedX;
}

public int getSpeedY() {
    return speedY;
}

public void setCenterX(int centerX) {
    this.centerX = centerX;
}

public void setCenterY(int centerY) {
    this.centerY = centerY;
}

public void setJumped(boolean jumped) {
    this.jumped = jumped;
}

public void setSpeedX(int speedX) {
    this.speedX = speedX;
}

public void setSpeedY(int speedY) {
    this.speedY = speedY;
}

public boolean isDucked() {
    return ducked;
}

public void setDucked(boolean ducked) {
    this.ducked = ducked;
}

public boolean isMovingRight() {
    return movingRight;
}

public void setMovingRight(boolean movingRight) {
    this.movingRight = movingRight;
}

public boolean isMovingLeft() {
    return movingLeft;
}

public void setMovingLeft(boolean movingLeft) {
    this.movingLeft = movingLeft;
}

public int getMOVESPEED() {
    return MOVESPEED;
}

public void setMOVESPEED(int mOVESPEED) {
    MOVESPEED = mOVESPEED;
}

final int JUMPSPEED=-15；
私用int移动速度=5；
最终int接地=202；
专用int centerX=350；
专用int中心Y=地面；
私有布尔值=false；
私有布尔左移=false；
私有布尔movingRight=false；
私有布尔值ducked=false；
私有静态背景bg1=Main.getBg1（）；
私有静态背景bg2=Main.getBg2（）；
私有整数速度x=0；
私有int=0；
公共无效更新（）{
//相应地移动角色或滚动背景。
如果（速度x<0）{
centerX+=speedX；
}
如果（速度x==0 | |速度x<0）{
bg1.setSpeedX（0）；
bg2.setSpeedX（0）；
}
如果（centerX 0）{
centerX+=speedX；
}
如果（speedX>0&¢erX>200）{
bg1.setSpeedX（-getMOVESPEED（））；
bg2.setSpeedX（-getMOVESPEED（））；
}
//更新Y位置
如果（中心+速度>=202）{
centerY=202；
}否则{
centerY+=快速；
}
//手柄跳跃
如果（跳转==真）{
速度+=1；
如果（中心+速度>=202）{
centerY=202；
速度=0；
跳跃=假；
}
}
//防止超出0的X坐标
如果（centerX+speedX=5）{
MOVESPEED++；
}
如果（移动速度>=7）{
移动速度=0；
}
}
}
公共空间左移（）{
if（ducked==false）{
speedX=-getMOVESPEED（）；
}
}
公共权利{
setMovingRight（假）；
停止（）；
}
公共void stopLeft（）{
setMovingLeft（假）；
停止（）；
}
公共停车场（）{
if（isMovingRight（）==false&&isMovingLeft（）==false）{
speedX=0；
}
if（isMovingRight（）==false&&isMovingLeft（）==true）{
左移（）；
}
if（isMovingRight（）==true&&isMovingLeft（）==false）{
moveRight（）；
}
}
公共跳转{
如果（跳转==错误）{
快速=跳跃速度；
跳跃=正确；
}
}
public int getCenterX（）{
返回centerX；
}
public int getCenterY（）{
返回中心；
}
公共布尔值（）{
返回跳；
}
public int getSpeedX（）{
返回速度x；
}
公共int getSpeedY（）{
迅速返回；
}
公共无效setCenterX（int centerX）{
this.centerX=centerX；
}
公共无效设置中心（内部中心）{
this.centerY=centerY；
}
公共无效集合跳跃（布尔跳跃）{
this.jumped=跳；
}
公共无效设置速度（int speedX）{
this.speedX=speedX；
}
公共空间设置速度（整数速度）{
这个。迅速的=迅速的；
}
公共布尔值isDucked（）{
退避；
}
公共无效设置为ducked（布尔值为ducked）{
这个.躲开了=躲开了；
}
公共布尔值isMovingRight（）{
返还动产权；
}
public void setMovingRight（布尔movingRight）{
this.movingRight=movingRight；
}
公共布尔值isMovingLeft（）{
返回左移；
}
公共void setMovingLeft（布尔值movingLeft）{
this.movingLeft=movingLeft；
}
public int getMOVESPEED（）{
返回速度；
}
public void setMOVESPEED（int mOVESPEED）{
移动速度=移动速度；
}

---

}使用布尔标志。这将进入您的

按键方法

private boolean canMoveUp = true; // same for up, down, etc.
...
case KeyEvent.VK_UP:
    if (canMoveUp)
    {
        System.out.println("Move up");
        canMoveUp = false;
    }
    break;

case KeyEvent.VK_UP:
    System.out.println("Stop moving up");
    canMoveUp = true;
    break;

这一点只会起作用一次。释放钥匙后，您必须使移动再次成为可能。这在您的
keyreased
方法中进行

private boolean canMoveUp = true; // same for up, down, etc.
...
case KeyEvent.VK_UP:
    if (canMoveUp)
    {
        System.out.println("Move up");
        canMoveUp = false;
    }
    break;

case KeyEvent.VK_UP:
    System.out.println("Stop moving up");
    canMoveUp = true;
    break;

这将确保您在按键时只移动一次，并允许您按该键任意次数。
没有出现相同的问题我认为问题在于如何滚动背景或角色或角色something@user3695829您可能需要指定一个计时器来实际注意差异，基于你的更新率和fps。你给出了相互矛盾的要求。“例如，当我单击一个键时，他移动了一定的距离，但他移动的距离与我按住键的时间成正比。”接下来，你说“我需要的是，即使我按了0.5美元秒或20美元秒，它也会移动相同的距离。”这表明距离与您按住键的时间不成正比——相反，距离是一个常量值。您需要说明按键、按住、然后释放与单击按键事件的动作是否相同，如果不同，如何不同？是的，我希望距离与我按住按键的时间不成正比，我希望它是一个常量。你能看看我的密码，告诉我该怎么做吗