Comment empêcher les balles rebondissantes qui se chevauchent dans une application Java ?

Java Bouncing Ball

Ce problème concerne une application Java conçue pour restituer plusieurs balles sur une interface qui rebondissent sur les frontières. L'utilisateur a réussi à implémenter le dessin d'une seule boule, mais rencontre des problèmes lorsqu'il tente d'ajouter une deuxième boule, car cela écrase la première boule.

Pour résoudre ce problème, une liste de boules peut être créée et parcourue. pour dessiner chaque boule, mais l'utilisateur rencontre des difficultés pour ajouter les deux boules au volet de contenu.

Analyse et solution

Le problème principal est le placement de deux composants opaques sur les uns au-dessus des autres, ce qui pourrait faire en sorte que l'un obscurcisse l'autre. Pour résoudre ce problème :

1. Un gestionnaire de disposition nul doit être utilisé pour empêcher le gestionnaire de disposition de dicter la disposition des balles.
2. La taille et l'emplacement du panneau de balle doivent être contrôlés. , assumant efficacement le rôle de gestionnaire de mise en page.
3. La vitesse et l'emplacement des balles doivent être randomisés pour réduire la probabilité de points de départ identiques et mouvement.
4. Seule la balle doit être mise à jour dans le contexte de l'EDT (Event Dispatch Thread).
5. L'utilisation des valeurs X/Y est redondante et peut être éliminée en exploitant les panneaux eux-mêmes .

Exemple de code

Un exemple de code amélioré intégrant ces éléments modifications :

public class Balls {

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

                JFrame frame = new JFrame();
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.setLayout(new BorderLayout());
                frame.add(new TheBalls());
                frame.setSize(400, 400);
                frame.setVisible(true);
            }
        });
    }

    public class TheBalls extends JPanel {

        public TheBalls() {
            setLayout(null);
            // Randomize the speed and direction...
            add(new Ball("red", 10 - (int) Math.round((Math.random() * 20)), 10 - (int) Math.round((Math.random() * 20))));
            add(new Ball("blue", 10 - (int) Math.round((Math.random() * 20)), 10 - (int) Math.round((Math.random() * 20))));
        }
    }

    public class Ball extends JPanel implements Runnable {

        Color color;
        int diameter;
        long delay;
        private int vx;
        private int vy;

        public Ball(String ballcolor, int xvelocity, int yvelocity) {
            if (ballcolor == "red") {
                color = Color.red;
            } else if (ballcolor == "blue") {
                color = Color.blue;
            } else if (ballcolor == "black") {
                color = Color.black;
            } else if (ballcolor == "cyan") {
                color = Color.cyan;
            } else if (ballcolor == "darkGray") {
                color = Color.darkGray;
            } else if (ballcolor == "gray") {
                color = Color.gray;
            } else if (ballcolor == "green") {
                color = Color.green;
            } else if (ballcolor == "yellow") {
                color = Color.yellow;
            } else if (ballcolor == "lightGray") {
                color = Color.lightGray;
            } else if (ballcolor == "magenta") {
                color = Color.magenta;
            } else if (ballcolor == "orange") {
                color = Color.orange;
            } else if (ballcolor == "pink") {
                color = Color.pink;
            } else if (ballcolor == "white") {
                color = Color.white;
            }
            diameter = 30;
            delay = 100;

            vx = xvelocity;
            vy = yvelocity;

            new Thread(this).start();

        }

        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2 = (Graphics2D) g;

            int x = getX();
            int y = getY();

            g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
            g.setColor(color);
            g.fillOval(0, 0, 30, 30); //adds color to circle
            g.setColor(Color.black);
            g2.drawOval(0, 0, 30, 30); //draws circle
        }

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

        public void run() {

            try {
                // Randamize the location...
                SwingUtilities.invokeAndWait(new Runnable() {
                    @Override
                    public void run() {
                        int x = (int) (Math.round(Math.random() * getParent().getWidth()));
                        int y = (int) (Math.round(Math.random() * getParent().getHeight()));

                        setLocation(x, y);
                    }
                });
            } catch (InterruptedException exp) {
                exp.printStackTrace();
            } catch (InvocationTargetException exp) {
                exp.printStackTrace();
            }

            while (isVisible()) {
                try {
                    Thread.sleep(delay);
                } catch (InterruptedException e) {
                    System.out.println("interrupted");
                }

                try {
                    SwingUtilities.invokeAndWait(new Runnable() {
                        @Override
                        public void run() {
                            move();
                            repaint();
                        }
                    });
                } catch (InterruptedException exp) {
                    exp.printStackTrace();
                } catch (InvocationTargetException exp) {
                    exp.printStackTrace();
                }
            }
        }

        public void move() {

            int x = getX();
            int y = getY();

            if (x + vx  getParent().getWidth()) {
                vx *= -1;
            }
            if (y + vy  getParent().getHeight()) {
                vy *= -1;
            }
            x += vx;
            y += vy;

            // Update the size and location...
            setSize(getPreferredSize());
            setLocation(x, y);

        }
    }
}

Approche alternative

Alternativement, un conteneur pourrait être créé pour abriter les balles, où les balles elles-mêmes ne sont pas des composants mais existent en tant que concepts virtuels avec suffisamment d'informations pour permettre de rebondir surfaces.

Problèmes d'évolutivité

Il est important de noter que l'extrait de code fourni utilise un thread distinct pour chaque balle, ce qui peut avoir un impact sur les ressources du système lorsque le nombre de balles augmente. Pour résoudre ce problème d'évolutivité, un seul thread BounceEngine peut être utilisé pour gérer tous les mouvements de balle.

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!