Java 单次按键连续移动？

我正试图用java编写一个程序，它涉及到让一个对象从一次按键中不断移动。想想吃豆人，你按一次向上，吃豆人继续向上，直到你按另一个键。如果可能的话，我希望代码保持简单。我最初的动作（一次按键=一次动作）是这样的：

public class AL extends KeyAdapter {
    public void keyPressed(KeyEvent e){
        int keyCode = e.getKeyCode();
        if(keyCode == e.VK_A){
            x -= 5;
        }
        if(keyCode == e.VK_D){
            x += 5;
        }
        if(keyCode == e.VK_W){
            y -= 5;
        }
        if(keyCode == e.VK_S){
            y += 5;
        }

    }

值中的x和y是椭圆形的位置。这很好用，但我希望它在我只按一次键后继续移动，而不是必须按住它才能继续移动。我尝试了一个带有布尔参数的while循环，该参数在为真时移动，在为假时不移动，但一旦激活循环，它就会冻结程序。下面是这段代码的一个示例：

public void keyPressed(KeyEvent e){
        int keyCode = e.getKeyCode();
        if(keyCode == e.VK_LEFT && moveL==false){
           moveL=true;
           moveR=false;
           moveU=false;
           moveD=false;
           while(moveL){
            x--;
            }
        }

---

请帮我弄清楚，我已经试了好几天了。我很感激你们能给我的帮助。谢谢。

您需要在单独的线程中处理移动。即：

public class Pacman implements Runnable
{
    public void run(){
        //moving code, i.e. in a while loop

        //every move will notify the EDT:
        SwingUtilities.invokeLater(new Runnable(){
            public void run(){
                //update the Swing here - i.e. move Pacman
            }
        }
    }

    public void startMoving(){
        new Thread(this).start();
    }

    //more methods to set speed, direction, etc...
}

然后在Gui类中保留对Pacman类实例的引用，并通过更改Pacman的参数来响应各种按键：

public void keyPressed(KeyEvent e){
    int keyCode = e.getKeyCode();
    if(keyCode == e.VK_LEFT){
        pacman.newDirection(LEFT); //for exmaple, enum with direction LEFT, RIGHT, UP, DOWN...
    }
    //etc... more logic
}

---

您需要在单独的线程中处理移动。即：

public class Pacman implements Runnable
{
    public void run(){
        //moving code, i.e. in a while loop

        //every move will notify the EDT:
        SwingUtilities.invokeLater(new Runnable(){
            public void run(){
                //update the Swing here - i.e. move Pacman
            }
        }
    }

    public void startMoving(){
        new Thread(this).start();
    }

    //more methods to set speed, direction, etc...
}

然后在Gui类中保留对Pacman类实例的引用，并通过更改Pacman的参数来响应各种按键：

public void keyPressed(KeyEvent e){
    int keyCode = e.getKeyCode();
    if(keyCode == e.VK_LEFT){
        pacman.newDirection(LEFT); //for exmaple, enum with direction LEFT, RIGHT, UP, DOWN...
    }
    //etc... more logic
}

---

基本概念围绕着“增量”或“变化”值的概念。然后，通过递增或递减状态值，将该值应用于要更改的状态

由于Swing的性质，您不能阻止事件分派线程，否则最终会阻止处理传入事件（如绘制和关键事件）

同样，除了EDT之外，您不应该尝试从任何线程更新任何UI组件（或可能影响UI的状态变量）

虽然可以应用一些技巧来促进这些需求，但最简单的方法是使用

javax.swing.Timer

，它在EDT内定期触发

actionPerformed

事件

当这种情况发生时，您将按规定的数量“更新”所有元素，并重新绘制屏幕

import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.KeyStroke;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class PacManTest {

    public static void main(String[] args) {
        new PacManTest();
    }

    public PacManTest() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                }

                JFrame frame = new JFrame("Test");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new MazePane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class PacMan {

        private int x;
        private int y;

        private int deltaX;
        private int deltaY;

        private BufferedImage sprite;

        public PacMan() {
            try {
                sprite = ImageIO.read(new File("PacMan.png"));
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }

        public void move(int x, int y) {
            deltaX = x;
            deltaY = y;
        }

        public void update(MazePane pane) {
            x += deltaX;
            y += deltaY;
            if (x + sprite.getWidth() > pane.getWidth()) {
                x = pane.getWidth() - sprite.getWidth();
            } else if (x < 0) {
                x = 0;
            }
            if (y + sprite.getHeight() > pane.getHeight()) {
                y = pane.getHeight() - sprite.getHeight();
            } else if (y < 0) {
                y = 0;
            }
        }

        public void paint(MazePane pane, Graphics2D g2d) {
            Graphics2D g = (Graphics2D) g2d.create();

            float angle = 0;
            if (deltaX != 0) {
                angle = deltaX > 0 ? 0 : 180;
            } else if (deltaY != 0) {
                angle = deltaY > 0 ? 90 : 270;                
            }
            AffineTransform t = new AffineTransform();
            t.translate(x, y);
            t.rotate(Math.toRadians(angle), sprite.getWidth() / 2, sprite.getHeight() / 2);
            g.setTransform(t);
            g.drawImage(sprite, 0, 0, pane);
            g.dispose();
        }

    }

    public class MazePane extends JPanel {

        private PacMan pacMan;
        public MazePane() {
            pacMan = new PacMan();
            Timer timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    pacMan.update(MazePane.this);
                    repaint();
                }
            });
            timer.start();
            InputMap im = getInputMap(WHEN_IN_FOCUSED_WINDOW);
            ActionMap am = getActionMap();

            im.put(KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0), "left");
            im.put(KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0), "right");
            im.put(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0), "up");
            im.put(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0), "down");

            am.put("left", new MoveAction(pacMan, -4, 0));
            am.put("right", new MoveAction(pacMan, 4, 0));
            am.put("up", new MoveAction(pacMan, 0, -4));
            am.put("down", new MoveAction(pacMan, 0, 4));
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            pacMan.paint(this, g2d);
            g2d.dispose();
        }

        public class MoveAction extends AbstractAction {

            private int deltaX;
            private int deltaY;
            private PacMan pacMan;

            public MoveAction(PacMan pacMan, int deltaX, int deltaY) {
                this.deltaX = deltaX;
                this.deltaY = deltaY;
                this.pacMan = pacMan;
            }

            @Override
            public void actionPerformed(ActionEvent e) {
                pacMan.move(deltaX, deltaY);
            }

        }        
    }
}

导入java.awt.BorderLayout；
导入java.awt.Dimension；
导入java.awt.EventQueue；
导入java.awt.Graphics；
导入java.awt.Graphics2D；
导入java.awt.event.ActionEvent；
导入java.awt.event.ActionListener；
导入java.awt.event.KeyEvent；
导入java.awt.geom.AffineTransform；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入javax.imageio.imageio；
导入javax.swing.AbstractAction；
导入javax.swing.ActionMap；
导入javax.swing.InputMap；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
导入javax.swing.KeyStroke；
导入javax.swing.Timer；
导入javax.swing.UIManager；
导入javax.swing.UnsupportedLookAndFeelException；
公共类包装测试{
公共静态void main（字符串[]args）{
新的PacManTest（）；
}
公共密码测试（）{
invokeLater（新的Runnable（）{
@凌驾
公开募捐{
试一试{
UIManager.setLookAndFeel（UIManager.getSystemLookAndFeelClassName（））；
}catch（ClassNotFoundException |实例化Exception | IllegalacessException |不支持ookandfeelException ex）{
}
JFrame=新JFrame（“测试”）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.setLayout（新的BorderLayout（））；
frame.add（新的MazePane（））；
frame.pack（）；
frame.setLocationRelativeTo（空）；
frame.setVisible（true）；
}
});
}
公共级吃豆人{
私人INTX；
私营企业；
私人所得税；
德尔泰私人酒店；
私有缓冲图像精灵；
公共吃豆人（）{
试一试{
sprite=ImageIO.read（新文件（“PacMan.png”）；
}捕获（IOEX异常）{
例如printStackTrace（）；
}
}
公共无效移动（整数x，整数y）{
deltaX=x；
deltaY=y；
}
公共无效更新（MazePane窗格）{
x+=代尔税；
y+=三角洲；
如果（x+sprite.getWidth（）>pane.getWidth（））{
x=pane.getWidth（）-sprite.getWidth（）；
}else如果（x<0）{
x=0；
}
如果（y+sprite.getHeight（）>pane.getHeight（））{
y=pane.getHeight（）-sprite.getHeight（）；
}else if（y<0）{
y=0；
}
}
公共空隙涂料（MazePane窗格，Graphics2D g2d）{
Graphics2D g=（Graphics2D）g2d.create（）；
浮动角度=0；
如果（deltaX！=0）{
角度=增量>0？0:180；
}否则如果（deltaY！=0）{
角度=三角洲>0？90:270；
}
AffineTransform t=新的AffineTransform（）；
t、 翻译（x，y）；
t、 旋转（Math.toRadians（angle）、sprite.getWidth（）/2、sprite.getHeight（）/2）；
g、 setTransform（t）；
g、 drawImage（精灵，0，0，窗格）；
g、 处置（）；
}
}
公共类MazePane扩展了JPanel{
私人吃豆人；
公共马泽潘（）{
吃豆人=新吃豆人（）；
计时器计时器=新计时器（40，新ActionListener（）{
@凌驾
已执行的公共无效操作（操作事件e）{
pacMan.update（MazePane.this）；
重新油漆（）；
}
});
timer.start（）；
InputMap im=getInputMap（在聚焦窗口中时）；
ActionMap am=getActionMap（）；
im.put（KeyStroke.getKeyStroke（KeyEvent.VK_LEFT，0），“LEFT”）；
im.put（KeyStroke.getKeyStroke（KeyEvent.VK_RIGHT，0），”