How Can I Display Multiple Bouncing Balls in a Java Application Without Overwriting Each Other?

Bouncing Balls in Java

Problem: Adding multiple balls to a Java application results in the initial ball being overwritten by the second, leading to only one visible ball.

Solution:

To resolve this issue and draw multiple bouncing balls on screen, consider the following approaches:

1. Using a Non-Opaque Layout Manager and Override Sizing:

• Remove the opaque layout manager to prevent component overlap and ensure proper control over the ball's size and location.
• Implement your own layout manager to control the size and location of the ball pane.

2. Randomize Ball Properties:

• Randomize the speed and starting location of each ball to reduce the likelihood of them colliding or starting in the same position.

3. Use the Event Dispatch Thread (EDT):

• Update the balls within the context of the EDT to ensure smooth and consistent graphical updates.

4. Use a Container Class for Balls:

• Instead of treating balls as opaque components, create a class that represents the properties of each ball, such as its color, speed, and position, without rendering any visuals.

5. Create a Separate Thread for Ball Movement:

• Implementing this approach may be resource-intensive, so explore other alternatives first.

Code Sample (Using Container Class for Balls):

public class Balls extends JPanel {

    private List<ball> ballsUp;

    // ... (Constructor and other methods)

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g.create();
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        for (Ball ball : ballsUp) {
            ball.paint(g2d);
        }
        g2d.dispose();
    }

    public List<ball> getBalls() {
        return ballsUp;
    }
}

public class Ball {

    private Color color;
    private Point location;
    private Dimension size;
    private Point speed;

    // ... (Constructor and other methods)

    protected void paint(Graphics2D g2d) {

        Point p = getLocation();
        if (p != null) {
            g2d.setColor(getColor());
            Dimension size = getSize();
            g2d.fillOval(p.x, p.y, size.width, size.height);
        }

    }
}

public class BounceEngine implements Runnable {

    private Balls parent;

    // ... (Constructor and other methods)

    public void run() {

        // Randomize ball properties and starting positions
        for (Ball ball : getParent().getBalls()) {
            // ... (Randomization logic)
        }

        while (getParent().isVisible()) {

            // Repaint the balls
            SwingUtilities.invokeLater(new Runnable() {
                @Override
                public void run() {
                    getParent().repaint();
                }
            });

            // Move each ball
            for (Ball ball : getParent().getBalls()) {
                move(ball);
            }

            // Delay between updates
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
            }

        }

    }

    // ... (Remaining code)

}</ball></ball>

This approach using a container class and a separate thread for ball movement provides greater control over the balls' behavior and allows for more complex ball animation.

The above is the detailed content of How Can I Display Multiple Bouncing Balls in a Java Application Without Overwriting Each Other?. For more information, please follow other related articles on the PHP Chinese website!