绘制时，对象不会出现在Java小程序中。 我怎么能在AWT中正确使用paint / repaint方法？

Question

I have an applet interface that is supposed to draw a ball on the screen and have it bounce off the edges when the run button is pressed. There are other functions, but they require this first one to work. When run is pressed currently, nothing happens. I don't think I am correctly drawing the object right. I have put in System.err.println() statements around, and checking the console the program does go to the right methods when the button is clicked. I just dont know what is wrong with the methods that should be drawing the object.

The code is almost 500 lines, but i'll paste it in this body if need be. Here it is: http://ideone.com/JL0B2

Answer 1

First of all, you have to override paint of drawingpanel : this is where you draw your circle. Currently the circle appears only when you press Run button because it's painted over the components.
During normal painting, the applet area is painted (this is where your current paint works), and the all the components you added are painted, over the already painted dot.

At the start of your program dot is null , so paint can't correctly draw it - it throws NullPointerException.

You don't have to "cache" the Graphics instance: always use the Graphics that is given to you in paint.

If you want the circle to move, you have to create another thread so that it updates the values and then schedules repaint of the drawingpanel .
And you don't have to repaint the entire applet, just the drawingpanel .

If you still need help, ask them in comments.

Edit:

Here's your drawingpanel where the dot is painted:

    Panel drawingpanel = new Panel() {
        public void paint(Graphics g) {
            if (dot == null) {
                return;
            }
            g.drawOval(dot.leftOf(), dot.topOf(), dot.widthOf(), dot.heightOf());
            g.fillOval(dot.leftOf(), dot.topOf(), dot.widthOf(), dot.heightOf());
        };
    };

And your Bounce applet does not override paint() method.

To implement animation, add Runnable interface to the implements section.
Add another field:

    volatile boolean running = false;
    private Thread animationThread;

Now let's implement simple animation:

    public void run() {
        while (running) {
            if (!showtails) {
                dot.setColor(drawingpanel.getBackground());
            }
            update();// check if speed, size, or shape changed
            draw();// draw next dot based on move(), or initial condition
            pause();
            move();// calculate and prepare the coordinates for the next
                   // iteration to be drawn
        }
    }

    public void draw() {
        drawingpanel.repaint();
    }

    public void pause() {
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void move() {
        dot.left--;
        dot.top--;
    }

And the final detail is the action handler:

    public void actionPerformed(ActionEvent e) {
        Object source = e.getSource();

        if (source == this.runbutton) {
            running = !running;
            if (animationThread == null) {
                animationThread = new Thread(this); 
            }

            if (running) {
                dot = new CircDot(100, 100, sizebar.getValue(), Color.RED);
                animationThread.start();
            }
        } else
            ...
    }

Here's how it works. Your implementation started run() in the action handler and didn't return the control back to the EDT, thus your application appeared hung: it stopped handling messages.

Now when Run button is clicked, the state field running is inversed, then a new thread is created if it wasn't already and started. The thread executes run() method. So the actions in the while body are executed until running becomes false .

• draw method call repaint() on the drawingpanel which schedules a paint operation. When the message queue is empty, the system will call its paint method to re-draw the panel.
• pause method calls Thread.sleep(500) to stop execution for 500 milliseconds. The less the number is, the faster the dot will move. The value here will depend somehow on speed. Never implement a pause with loop : you just waste processor time for no gain and you can't predict how much time it will take.
• move just decreases top and left coordinates of dot so that it moves to the left top corner of the window.

It is worth noting that running is declared volatile because the field is accessed from multiple threads without other means of synchronization. If it's not there, the running animation may not see its modification from the EDT in the action handler.