Comment puis-je afficher plusieurs balles rebondissantes dans une application Java sans s'écraser les unes les autres ?

Balles rebondissantes en Java

Problème : L'ajout de plusieurs balles à une application Java entraîne la balle initiale étant écrasé par le second, conduisant à un seul visible balle.

Solution :

Pour résoudre ce problème et dessiner plusieurs balles rebondissantes à l'écran, envisagez les approches suivantes :

< h4>1. Utilisation d'un gestionnaire de mise en page non opaque et remplacement du dimensionnement :

• Supprimez le gestionnaire de mise en page opaque pour éviter le chevauchement des composants et garantir un contrôle approprié sur la taille et l'emplacement de la balle.
• Implémentez votre propre gestionnaire de mise en page pour contrôler la taille et l'emplacement de la balle volet.

2. Propriétés aléatoires de la balle :

• Randomisez la vitesse et l'emplacement de départ de chaque balle pour réduire le risque qu'elles entrent en collision ou démarrent dans la même position.

3. Utilisez le fil de répartition d'événements (EDT) :

• Mettez à jour les balles dans le contexte de l'EDT pour garantir des mises à jour graphiques fluides et cohérentes.

< ;h4>4. Utilisez une classe conteneur pour les balles :

• Au lieu de traiter les balles comme des composants opaques, créez une classe qui représente les propriétés de chaque balle, telles que sa couleur, sa vitesse et sa position, sans rendre aucun visuel.

5. Créez un fil distinct pour le mouvement de la balle :

• La mise en œuvre de cette approche peut nécessiter beaucoup de ressources, alors explorez d'abord d'autres alternatives.

Exemple de code (utilisation de la classe conteneur pour les balles) :

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)

}

Ceci L'approche utilisant une classe conteneur et un thread séparé pour le mouvement de la balle offre un meilleur contrôle sur le comportement des balles et permet une animation de balle plus complexe.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!