Bagaimana untuk Menghidupkan Berbilang Bola Melantun dengan Cekap di Java Tanpa Bertindih?

Bola Melantun Java

Masalah:

Apabila melukis berbilang bola pada skrin yang melantun dari tepi bingkai , bola kedua menimpa bola awal.

Diberikan Kod:

Kod yang disediakan cuba menarik berbilang bola yang melantun, tetapi bola kedua menimpa bola awal.

Dengan pendekatan semasa, isu berikut hadir:

• Komponen legap diletakkan di atas satu sama lain.
• Pengurus reka letak tidak dinyatakan, yang menjejaskan penempatan bola.
• Kawalan saiz dan lokasi bola tidak dikendalikan dengan berkesan.
• Kelajuan dan lokasi bola tidak rawak.
• Kemas kini bola harus dilakukan dalam konteks EDT.
• Nilai X/Y tidak perlu, kerana panel boleh digunakan.

Isu Kebolehskalaan dengan Berbilang Benang:

Pendekatan semasa melibatkan mencipta benang berasingan untuk setiap bola . Ini boleh menegangkan sumber sistem, terutamanya apabila bilangan bola bertambah.

Pendekatan Alternatif:

Daripada menggunakan komponen untuk setiap bola, pertimbangkan untuk mencipta bekas untuk bola dan menggunakan gelung animasi mudah untuk mengemas kini kedudukan mereka dan melukis semula mereka. Pendekatan ini lebih berskala.

Pelaksanaan:

Berikut ialah pelaksanaan alternatif yang menangani isu yang dinyatakan di atas:

public class AnimatedBalls {

    public static void main(String[] args) {
        new AnimatedBalls();
    }

    public AnimatedBalls() {
        EventQueue.invokeLater(() -> {
            JFrame frame = new JFrame("Bouncing Balls");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setSize(400, 400);
            frame.setVisible(true);

            // Create a container for the balls
            BallsPane ballsPane = new BallsPane();
            frame.add(ballsPane);
        });
    }

    public class BallsPane extends JPanel {

        private List<Ball> balls;

        public BallsPane() {
            balls = new ArrayList<>();

            for (int i = 0; i < 10; i++) {
                Random random = new Random();
                int x = (int) (Math.random() * getWidth());
                int y = (int) (Math.random() * getHeight());
                int vx = (int) (Math.random() * 10) - 5;
                int vy = (int) (Math.random() * 10) - 5;
                Ball ball = new Ball(x, y, vx, vy);
                balls.add(ball);
            }
        }

        protected void paintComponent(Graphics g) {
            super.paintComponent(g);

            for (Ball ball : balls) {
                ball.draw(g);
            }
        }

    }

    public class Ball {

        private int x;
        private int y;
        private int vx;
        private int vy;

        public Ball() {
            this(0, 0, 0, 0);
        }

        public Ball(int x, int y, int vx, int vy) {
            this.x = x;
            this.y = y;
            this.vx = vx;
            this.vy = vy;
        }

        public void update() {
            // Bounce off the edges of the frame
            if (x < 0 || x > getWidth())
                vx *= -1;
            if (y < 0 || y > getHeight())
                vy *= -1;

            // Update the ball's position
            x += vx;
            y += vy;
        }

        public void draw(Graphics g) {
            // Draw the ball as a filled circle
            g.setColor(Color.RED);
            g.fillOval(x - 5, y - 5, 10, 10);
        }

    }

}

Dalam pelaksanaan alternatif ini :

• Satu gelung animasi mengemas kini semua bola.
• Bola diwakili oleh struktur data ringkas (bukan komponen).
• Pemegang gelung animasi yang melantun dari tepi bingkai.
• Rawak digunakan untuk mempelbagaikan kelajuan permulaan dan lokasi bola.
• Kaedah kemas kini() mengira kedudukan baharu setiap bola.
• Kaedah seri() menjadikan bola sebagai bulatan terisi.

Atas ialah kandungan terperinci Bagaimana untuk Menghidupkan Berbilang Bola Melantun dengan Cekap di Java Tanpa Bertindih?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!