我的 Java 弹跳球以更大的速度弹起

Question

I'm making a simple Java program to bounce a ball up and down. The problem is that the ball bounces up higher than its starting point with each bounce. I expect the ball to bounce back up exactly to the height that it started from.

The ball physics can be found in the circle class in the doPhysics() method where I suspect the problem can be found

import java.awt.*;
import java.util.*;

public class Main{
    
    public static Frame frame = new Frame();
    public static Physics physics = new Physics();
    public static ArrayList<Circle> circles = new ArrayList<Circle>(); //array for the points

    public static void main(String args[]) {
        Circle circle = new Circle(100, 300, 50, Color.BLACK);
        circles.add(circle);
        
        run();
    }
    
    public static void run() {
        physics.timer.start();
    }

}

import java.awt.*;

public class Circle {
    
    private int x;
    private int y;
    
    private double xAccel= 0;
    private double yAccel = 0;
    
    private double xVel= 0;
    private double yVel = 0;
    
    private Color colour;
    private int radius;
    
    public Circle(int x, int y, int radius, Color colour) {
        setX(x);
        setY(y);
        setRadius(radius);
        setColour(colour);
    }
    
    public void draw(Graphics2D g2d) {
        g2d.setColor(colour);
        g2d.fillOval(x, y, radius*2, radius*2);
    }
    
    public void doPhysics() {
        hitGround();
        System.out.println(yVel);
        
        yVel += Physics.getGravity();
        y -= yVel;
    }
    
    public void hitGround() {
        if(y + radius*2 > Frame.panel.h ) {
            yVel = -yVel;
        }
    }
    
    public void setX(int x) {
        this.x = x;
    }
    
    public void setY(int y) {
        this.y = y;
    }
    
    public void setColour(Color colour) {
        this.colour = colour;
    }
    
    public void setRadius(int radius) {
        this.radius = radius;
    }
    
    public int getX() {
        return x;
    }
    
    public int getY() {
        return y;
    }
    
    public Color getColour() {
        return colour;
    }
    
    public int getRadius() {
        return radius;
    }
}

import java.awt.*;
import javax.swing.*;

class Frame extends JFrame {
    
    public static Panel panel;

    public Frame() {
        panel = new Panel();
        this.setTitle("Fun");
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.add(panel);
        this.pack();
        this.setLocationRelativeTo(null);
        this.setVisible(true);
    }

}

class Panel extends JPanel {
    
    public int w = 500;
    public int h = 500;
    
    public Panel() {
        this.setPreferredSize(new Dimension(w, h));
        this.setBackground(Color.red);
    }
    
    public void paint(Graphics g) {
        super.paint(g);
        
        Graphics2D g2d = (Graphics2D) g;
        
        for(Circle circle : Main.circles) {
            circle.draw(g2d);
        }
    }
    
}

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.Timer;

public class Physics implements ActionListener {
    
    private static double gravity = -.1;
    public Timer timer;
    
    public Physics() {
        timer = new Timer(1, this);
    }
    
    public static double getGravity() {
        return gravity;
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        for(Circle circle : Main.circles) {
            circle.doPhysics();
        }
        Main.frame.repaint();
    }
    
}

Answer 1

The problem is mainly caused by using integer values for position ( x and y ). On each iteration the values are rounded and the errors get accumulated.
Solution: declare double x and double y and only use the rounded integer values for drawing.

Above should reduce the problem, but not completely solve it. The code is doing a rough integration over time ¹ by using the velocity calculated after the time interval (see Numerical Integration ). This can be improved by doing an average of the velocities before and after it was changed. Roughly:

double preVel = yVel;
yVel += Physics.getGravity(); 
y -= (preVel + yVel)/2;

which can be simplified (pure math) to:

yVel += Physics.getGravity();
y -= yVel - Physics.getGravity()/2;

This should work fine since the acceleration is constant. Not the case if the acceleration is also changing. And it is also susceptible to precision errors being accumulated over time.

---

1 - see Numerical integration and Temporal discretization