如何在一個JPanel上繪制多個相同類的對象？

Question

我是一名大學生，我的作業遇到了麻煩。 通常，我只是去實驗室時間問電訊局長，但他整周都病了，所以我們沒有任何實驗室時間，這個作業要在星期一完成！

我遇到的特定問題與創建一個Java應用程序有關，該應用程序顯示帶有按鈕的框架，允許用戶創建一個球，該球開始在屏幕上彈起並反彈出框架邊界。

上一個作業的練習之一是創建一個類似的程序，但是運行該程序時，將立即顯示一個球反彈。 （我必須開始工作）現在，我們必須修改代碼並加入允許我們創建多個球的按鈕。

起初，我認為這將是一個簡單的修改，但是現在我對如何實際實例化Ball對象感到困惑。 我的思考過程是，我首先必須使ReboundPanel和按鈕面板出現（起作用），然后每當用戶按下按鈕時，都會實例化一個新的Ball對象並將其顯示在ReboundPanel上。 （目前不起作用）

感謝大家的幫助！

主程序：

import java.awt.*;

public class Rebound {

public static void main(String[] args) {

    JFrame frame = new JFrame ("Rebound");
    frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
    frame.getContentPane().setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.Y_AXIS));

    JPanel reboundPanel = new ReboundPanel();
    JPanel buttonPanel = new ButtonPanel();
    frame.getContentPane().add(reboundPanel);
    frame.getContentPane().add(buttonPanel);
    frame.pack();
    frame.setVisible(true);
}
}

應出現球的面板：

import java.awt.*;

public class ReboundPanel extends JPanel {

private final int WIDTH = 400, HEIGHT = 300;

public ReboundPanel() {

    setPreferredSize (new Dimension(WIDTH, HEIGHT));
    setBackground (Color.black);

}
}

按鈕面板：

import java.awt.*;

public class ButtonPanel extends JPanel {

private final int WIDTH = 400, HEIGHT = 35;

public ButtonPanel() {

    setPreferredSize (new Dimension(WIDTH, HEIGHT));
    setBackground (Color.GRAY);

    JButton button = new JButton("New ball");
    add(button);

    button.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent event) {

            new Ball(); 

        }
    });
}
}

球類：

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class Ball extends JPanel {

private final int DELAY = 20, IMAGE_SIZE = 35;

private ImageIcon image;
private Timer timer;
private int x, y, moveX, moveY;


public Ball() {

    timer = new Timer(DELAY, new ReboundListener());
    image = new ImageIcon ("/src/pa1/images/earth.gif");
    x = 0;
    y = 40;
    moveX = moveY = 3;
    draw(null);
    timer.start();
}

public void draw(Graphics page) {

    super.paintComponent (page);
    image.paintIcon (new ReboundPanel(), page, x, y);
}

private class ReboundListener implements ActionListener {

    public void actionPerformed (ActionEvent event) {

        x += moveX;
        y += moveY;

        if (x <= 0 || x >= WIDTH-IMAGE_SIZE)
            moveX = moveX * -1;

        if (y <= 0 || x >= WIDTH-IMAGE_SIZE)
            moveY = moveY * -1;

        repaint();
    }
}
}

Answer 1

考慮一下應用程序元素之間的關系，並讓其有助於形成類和對象設計。

描述：

該應用程序將具有一個窗口，其中包含一個按鈕和一個容納0個或多個球的容器區域。 單擊該按鈕時，應將一個新球添加到容器中。 球應以固定的速度繞其容器運動，並從容器的邊界反彈。

設計：

此說明向我們介紹了許多有關如何構造代碼的信息。 我們有一些名詞：（應用程序），窗口，按鈕，容器，邊界和球。 我們有一些動詞：（具有，包含，保持，添加），move [ball]，bounce [ball]，click [button]。

名詞提示可能要實現的類。 以及在相關類中要實現的可能方法的動詞。

讓我們創建一個代表窗口的類並將其稱為Rebound，一個代表容器的類稱為BallPanel，另一個代表球的類稱為Ball。 在這種情況下，窗口和應用程序可以認為是相同的。 事實證明，無需為按鈕創建單獨的類，就可以將按鈕整潔地實現。 邊界足夠簡單，可以用整數表示。

上面我已經解釋了一種方法來幫助解決問題，下面我將提供一種可能的實現。 這些旨在提供一些指導性提示以幫助您理解。 您可以通過多種方式分析此問題或實施解決方案，希望對您有所幫助。

import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.util.ArrayList;
import java.util.List;

import javax.swing.AbstractAction;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.SwingUtilities;
import javax.swing.Timer;

public class Rebound extends JFrame {
    /* Milliseconds between each time balls move */
    static final int MOVE_DELAY = 20;

    /* The JButton for adding a new ball. An AbstractAction
     * provides a neat way to specify the label and on-click
     * code for the button inline */
    JButton addBallButton = new JButton(new AbstractAction("Add ball") {
        public void actionPerformed(ActionEvent e) {
            ballContainer.addBall();
        }
    });

    /* The Panel for holding the balls. It will need to
     * keep tracks of each ball, so we'll make it a subclass
     * of JPanel with extra code for the ball management (see
     * the definition, after the end of the Rebound class) */
    BallPanel ballContainer = new BallPanel();

    public Rebound() {
        super("Rebound");
        setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
        getContentPane().setLayout(new BoxLayout(getContentPane(), BoxLayout.Y_AXIS));

        /* There was no neat way to specify the button size
         * when we declared it, so let's do that now */
        addBallButton.setPreferredSize(new Dimension(400, 35));

        /* Add the components to this window */
        getContentPane().add(addBallButton);
        getContentPane().add(ballContainer);

        pack();

        /* Create a timer that will send an ActionEvent
         * to our BallPanel every MOVE_DELAY milliseconds */
        new Timer(MOVE_DELAY, ballContainer).start();
    }

    /* The entry point for our program */
    public static void main(String[] args) {
        /* We use this utility to ensure that code
         * relating to Swing components is executed
         * on the correct thread (the Swing event 
         * dispatcher thread) */
        SwingUtilities.invokeLater(new Runnable() {
            public void run() {
                new Rebound().setVisible(true);
            }
        });
    }
}

/* Our subclass of JPanel that also manages a list of
 * balls. It implements ActionListener so that it can
 * act on the Timer event we set up in the Rebound class */
class BallPanel extends JPanel implements ActionListener {
    /* An automatically expanding list structure that can
     * contain 0 or more Ball objects. We'll create a Ball
     * class to manage the position, movement and draw code
     * for each ball. */
    List<Ball> balls = new ArrayList<Ball>();
    /* Let's add some code that will be run
     * when the panel is resized (which will happen
     * if its window is resized.) We need to make sure
     * that each Ball is told about the new bounds
     * of the component, so it knows that the place
     * where it should bounce has changed */
    public BallPanel() {
        super();
        setPreferredSize(new Dimension(400,300));
        addComponentListener(new ComponentAdapter() {
            public void componentResized(ComponentEvent e) {
                if (BallPanel.this == e.getComponent()) {
                    for (Ball ball : balls) {
                        ball.setBounds(getWidth(), getHeight());
                    }
                }
            }
        });
    }

    /* This method is part of the JPanel class we are subclassing.
     * Here we change the implementation of the method, ensuring
     * we call the original implementation so that we are only
     * adding to what it does. */
    public void paintComponent(Graphics g) {
        /* Call the original implementation of this method */
        super.paintComponent(g);

        /* Lets draw a black border around the bounds of the component
         * to make it clear where the balls should rebound from */
        g.drawRect(0,0,getWidth(),getHeight());

        /* Now lets draw all the balls we currently have stored in
         * our list. */
        for (Ball ball : balls) {
            ball.draw(g);
        }
    }
    /* This method will add a new Ball into our list. Remember
     * from earlier that we call this when our button is clicked. */
    public void addBall() { 
        balls.add(new Ball(this,10,10,getWidth(),getHeight())); 
    }
    /* This method will receive the event from Timer we set up in
     * the Rebound class. We want it to cause all the ball to
     * move to their next position. */
    public void actionPerformed(ActionEvent e) {
        for(Ball ball : balls) {
            ball.move();
        }
        /* Request that Swing repaints this JPanel. This should
         * cause the paintComponent() method we implemented
         * above to be called soon after. */
        repaint();
    }
}
/* This is our class for keeping track of an individual ball
 * and it's position, movement and how it is drawn. */
class Ball {
    /* Let's say all balls will have the same diameter of 35.
     * The static modifier says that this is a value
     * that is shared by all instances of Ball. */ 
    static final int SIZE = 35;
    /* Let's say all balls will have a speed in both the X and Y
     * axes of 3. The static modifier says that this is a value
     * that is shared by all instances of Ball. */ 
    static final int SPEED = 3;
    /* Each ball needs to know its position, which we will store
     * as x and y coordinates in 2D space */
    int x, y; 
    /* Each ball needs to know the bounds in which it lives, so
     * it knows when to bounce. We'll be assuming the minimum
     * bound is 0,0 in 2D space. The maximum bound will be
     * maxX,mayY in 2D space. We could have made these static
     * and shared by all balls, but that means we would have
     * to remember to change them to not be static if in the
     * future we wanted Ball to be used on more than one JPanel.
     * If we didn't remember, then we'd see some buggy behaviour. */
    int maxX, maxY;
    /* Each ball needs to know its current speed in the X and Y 
     * directions. We can use positive and negative values to
     * keep track of the direction of the ball's movement. */
    int speedX = SPEED, speedY = SPEED;
    /* Each ball needs to know which panel it is being drawn to
     * (this is needed by ImageIcon#drawImage()). */
    JPanel panel;
    public Ball(JPanel panel, int x, int y, int maxX, int maxY) { 
        this.x = x; this.y = y;
        this.maxX = maxX; this.maxY = maxY;
        this.panel = panel;
    }
    public void setBounds(int maxX, int maxY) {
        this.maxX = maxX; this.maxY = maxY;
    }
    /* This method updates the position of this ball, using
     * the current speed and bounds to work out what the new
     * position should be.
     * This should be called by our BallPanel#actionPerformed()
     * method in response to the Timer we set up in the Rebound
     * class. */
    public void move() {
        x += speedX;
        y += speedY;
        // Approx bounce, okay for small speed
        if (x<0) { speedX=-speedX; x=0; }
        if (y<0) { speedY=-speedY; y=0; }
        if (x+SIZE>maxX) { speedX=-speedX; x=maxX-SIZE; }
        if (y+SIZE>maxY) { speedY=-speedY; y=maxY-SIZE; }
    }
    /* This method is responsible for drawing this ball on
     * the provided graphics context (which should come from
     * the JPanel associated with the ball). We also have
     * the panel, should we need it (ImageIcon#drawImage() needs 
     * this, but Graphics#drawOval() does not.)
     */
    public void draw(Graphics g) {
        //image.paintIcon(panel, g, x, y); - commented out because I don't have an ImageIcon
        g.drawOval(x, y, SIZE, SIZE);
    }
}

Answer 2

我讓ReboundPanel負責告訴球移動和繪畫-它有一個計時器和所有球的ArrayList。 我標記了對Rebound.java和ButtonPanel.java的更改。 其他兩個變化很大，沒有任何意義。

反彈

import java.awt.*;
import javax.swing.*;

public class Rebound {

public static void main(String[] args) {

    JFrame frame = new JFrame ("Rebound");
    frame.setDefaultCloseOperation (JFrame.EXIT_ON_CLOSE);
    frame.getContentPane().setLayout(new BoxLayout(frame.getContentPane(), BoxLayout.Y_AXIS));

    ReboundPanel reboundPanel = new ReboundPanel(); /****/
    JPanel buttonPanel = new ButtonPanel(reboundPanel); /****/
    frame.getContentPane().add(reboundPanel);
    frame.getContentPane().add(buttonPanel);
    frame.pack();
    frame.setVisible(true);
}
}

ReboundPanel.java

import java.awt.*;
import javax.swing.*;
import java.awt.event.*;
import java.util.ArrayList;

public class ReboundPanel extends JPanel {

private final int WIDTH = 400, HEIGHT = 300;
private final int DELAY = 20;
private ArrayList<Ball> balls;
private Timer timer;

public ReboundPanel() {

    balls = new ArrayList<Ball>();
    timer = new Timer(DELAY, new ReboundListener());
    setPreferredSize (new Dimension(WIDTH, HEIGHT));
    setBackground (Color.black);
    timer.start();

}

public void addBall(Ball b) {

    balls.add(b);
}

protected void paintComponent(Graphics g) {

    super.paintComponent(g);

    for (Ball b : balls) {

        b.paint(g);
    }
}

private class ReboundListener implements ActionListener {

    public void actionPerformed (ActionEvent event) {

        for (Ball b : balls) {

            b.move(getWidth(), getHeight());
        }
        repaint();
    }
}
}

ButtonPanel.java

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;

public class ButtonPanel extends JPanel {

private final int WIDTH = 400, HEIGHT = 35;

public ButtonPanel(final ReboundPanel panel) { /****/

    setPreferredSize (new Dimension(WIDTH, HEIGHT));
    setBackground (Color.GRAY);

    JButton button = new JButton("New ball");
    add(button);

    button.addActionListener(new ActionListener() {

        public void actionPerformed(ActionEvent event) {

            panel.addBall(new Ball()); /****/

        }
    });
}
}

Ball.java

import javax.swing.*;
import java.awt.*;

public class Ball {

private final int IMAGE_SIZE = 15;
private int x, y, moveX, moveY;
private ImageIcon image;

public Ball() {

    x = 0;
    y = 40;
    moveX = moveY = 3;
    image = new ImageIcon("/src/pa1/images/earth.gif");
}

public void move(int width, int height) {

    x += moveX;
    y += moveY;

    if (x <= 0 || x >= width - IMAGE_SIZE)
        moveX = moveX * -1;

    if (y <= 0 || y >= height - IMAGE_SIZE)
        moveY = moveY * -1;
}
public void paint(Graphics g) {

    image.paintIcon(null, g, x, y);
}
}