Java两小球碰撞轨迹交互模拟程序修改需求咨询

Absolutely, adding ball-to-ball collision is totally feasible—let's fix up your code and add that functionality step by step. First, let's address some bugs in your initial code that are causing odd behavior, then we'll implement the collision logic.

First, Fix the Existing Issues in Your Code #

Your current code has a few small bugs that are making the second ball behave strangely:

• The second ball's Y-position is set to x2, which makes it move diagonally instead of horizontally. Let's fix that to a fixed Y-value (like 160, matching the first ball) so both balls move along the same horizontal plane for collision.
• The boundary check for the second ball is incorrect (x2 < 350 makes no sense here)—it should mirror the first ball's check for the right boundary (x2 > 500).
• The position update for the second ball is wrong (x2 = -x2 + velX2)—it should be x2 += velX2 like the first ball.
• Starting the Timer inside paintComponent will restart it every time the panel repaints, which can cause erratic movement. Move the tm.start() call to the class constructor instead.

Adding Collision Detection & Handling #

To detect collision, we need to check if the two balls (rectangles) overlap. For horizontal movement, this means:

• The right edge of the first ball is greater than the left edge of the second ball
• The left edge of the first ball is less than the right edge of the second ball
• The vertical ranges overlap (since our balls are on the same Y position, this is already handled)

For a realistic elastic collision (assuming both balls have the same mass), we can simply swap their horizontal velocities when they collide. If you want to handle different masses later, you can use momentum/kinetic conservation formulas, but swapping velocities is a great starting point for a simple simulation.

Modified Working Code #

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;

public class BallCollision extends JPanel implements ActionListener {
    Timer tm = new Timer(5, this);
    // Ball 1 (red)
    int x1 = 0;
    final int y1 = 160;
    int velX1 = 2;
    final int SIZE = 10;
    // Ball 2 (blue)
    int x2 = 500;
    final int y2 = 160;
    int velX2 = -2;

    public BallCollision() {
        tm.start(); // Start timer once in constructor
    }

    @Override
    public void paintComponent(Graphics g) {
        super.paintComponent(g);
        // Draw red ball
        g.setColor(Color.RED);
        g.fillRect(x1, y1, SIZE, SIZE);
        // Draw blue ball
        g.setColor(Color.BLUE);
        g.fillRect(x2, y2, SIZE, SIZE);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        // Boundary checks for both balls
        if (x1 < 0 || x1 + SIZE > getWidth()) {
            velX1 = -velX1;
        }
        if (x2 < 0 || x2 + SIZE > getWidth()) {
            velX2 = -velX2;
        }

        // Update positions
        x1 += velX1;
        x2 += velX2;

        // Collision detection using rectangles for each ball
        Rectangle ball1 = new Rectangle(x1, y1, SIZE, SIZE);
        Rectangle ball2 = new Rectangle(x2, y2, SIZE, SIZE);

        if (ball1.intersects(ball2)) {
            // Swap velocities (elastic collision, equal mass)
            int tempVel = velX1;
            velX1 = velX2;
            velX2 = tempVel;

            // Adjust positions slightly to prevent sticking
            if (velX1 > 0) {
                x1 = ball2.x - SIZE;
            } else {
                x1 = ball2.x + SIZE;
            }
        }

        repaint();
    }

    public static void main(String[] args) {
        BallCollision panel = new BallCollision();
        JFrame frame = new JFrame();
        frame.setTitle("Ball Collision Simulation");
        frame.setSize(600, 400);
        frame.setVisible(true);
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.add(panel);
    }
}

Key Changes Explained: #

• Renamed the class to BallCollision for clarity (following Java's PascalCase class naming convention).
• Used Rectangle objects to simplify collision detection—intersects() handles all the boundary overlap checks for us automatically.
• Added a position adjustment after collision to prevent the balls from sticking together (a common quirk in simple physics simulations).
• Fixed all initial movement bugs so both balls move smoothly within the window bounds.
• Set both balls to the same Y position so they can collide head-on.

If you want to expand this later, you could add vertical movement, different ball sizes/masses, or even gravity—this foundation gives you a solid starting point.

内容的提问来源于stack exchange，提问作者Stefano Barone