当面对一个问题时，我倾向于回到基础，我知道该怎么做？

我知道我可以：

• 计算两点之间的距离
• 在给定的持续时间内将对象移动一行。

所以我们知道：

• 起点
• 终点

由此我们可以计算出两点之间的距离。

double distance = Math.sqrt(
                    (startX - targetX) * (startX - targetX)
                    + (startY - targetY) * (startY - targetY));

有了这个，我们可以根据所需的速度计算出在两点之间旅行所需的时间

time = distance / speed

其中速度是一个常量（0.1在我的示例中，使其更小以使其更慢）

有了这些信息，我们知道我们必须旅行多长时间，我们可以根据我们开始时（点击鼠标时）和现在之间的差异计算沿着线/路径的进度。

假设startTime是我们开始移动的时间，runningTime是我们需要运行的时间量，以保持恒定的速度

然后我们可以使用类似的东西来计算我们当前的进度…

long duration = System.currentTimeMillis() - startTime;
double progress = duration / runTime;

由此我们可以根据当前持续时间计算出沿线的位置…

double x = (int) (startX + ((targetX - startX) * progress));
double y = (int) (startY + ((targetY - startY) * progress));

作为概念证明。抱歉，你没有提到你使用的是什么框架；）

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class TestMove {

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

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

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private Rectangle champion;
        private Line2D path;

        private double speed = 0.1;

        private Timer timer;
        private Long startTime;

        private double targetX, targetY;
        private double startX, startY;
        private double runTime;

        public TestPane() {
            champion = new Rectangle(95, 95, 10, 10);

            addMouseListener(new MouseAdapter() {
                @Override
                public void mouseClicked(MouseEvent e) {
                    timer.stop();
                    calculateChampionMovement(e.getX(), e.getY(), champion);
                    startTime = System.currentTimeMillis();
                    timer.start();
                }
            });

            timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    if (targetX == champion.getCenterX() && targetY == champion.getCenterY()) {
                        System.out.println("Stopped as same");
                        timer.stop();
                    }

                    long duration = System.currentTimeMillis() - startTime;
                    double progress = duration / runTime;

                    if (progress >= 1.0) {
                        System.out.println("Stopped out of time");
                        progress = 1.0;
                        timer.stop();
                    }

                    double x = (int) (startX + ((targetX - startX) * progress));
                    double y = (int) (startY + ((targetY - startY) * progress));

                    // x/y are the center points, need to adjust them so the shape
                    // moves about the center point
                    champion.setRect(x - 5, y - 5, 10, 10);

                    repaint();
                }
            });
        }

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

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            g2d.draw(champion);
            if (path != null) {
                g2d.setColor(Color.RED);
                g2d.draw(path);
            }
            g2d.dispose();
        }

        public void calculateChampionMovement(double x, double y, Rectangle champion) {

            if (x != champion.getCenterX() || y != champion.getCenterY()) {

                targetX = x;
                targetY = y;

                startX = champion.getCenterX();
                startY = champion.getCenterY();

                path = new Line2D.Double(
                                champion.getCenterX(),
                                champion.getCenterY(),
                                x, y);

                double distance = Math.sqrt(
                                (startX - targetX) * (startX - targetX)
                                + (startY - targetY) * (startY - targetY));

                runTime = distance / (double)speed;

            }
        }
    }

}

使用毕达哥拉斯定理，我们可以计算距离D即sqrt（（target etx-startx）^2（target et-starty）^2）。

使用您的速度变量（我称之为V），我们可以将时间变量T计算为D/V，即速度上的距离。

然后，我们可以得到单独的x和y速度，分别为x距离/T和y距离/T或（target etx-start x）/T和（target enty-start at）/T（注意，如果T==0的异常必须被实现以避免错误）

使用时间片段来计算x和y速度，使总速度保持不变，在计算上是不必要的，唯一的好处是我们避免除以零，但这又是一个简单的if语句（if（T！=0.0））。

使用这种或类似的方法将使您的程序运行得更快，因为所需的计算量更少。节省的时间太少，在现代计算机上不太明显，但它使代码更干净。祝你的项目好运。