Java Jpanel油漆

Question

I have this example of a java jpanel:

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

    public class JavaGame extends JFrame {

    public JavaGame() {
    setTitle("Game");
    setSize(500,500);
    setResizable(false);
    setVisible(true);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void paint(Graphics g) {
    g.drawString("Hello World!",75,75);
    }

    public static void main(String[] args) {

    new JavaGame();

    }

    }

So, we just define the method paint , and we create new JavaGame object, and it just calls paint . I don't get two things:

1. new JavaGame() - shouldn't we assign a object name like obj = new JavaGame()?
2. Shouldn't we call the method paint like obj.paint()?

I have basic understanding of OOP, but this piece of code confuses me. Could someone please explain it to me?

Answer 1

new JavaGame() - shouldn't we assign a object name like obj = new JavaGame()?

This gets to the important distinction between objects and reference variables. What is most important here is creating a JavaGame object, which you do by new JavaGame() . Since this object displays the JFrame in its constructor, then simply creating the object is all that is needed to create the display, and you don't need to assign the object to any variable.

Note that objects don't have names, but rather, some variables do. For instance, if you created a Foo object, and assigned it to a bar variable:

Foo bar = new Foo();

But then assigned the same object to a baz variable:

Foo baz = bar;

Both bar and baz refer to the exact same Foo object. What then is the object's name? Again, object names don't exist and are meaningless.

---

Shouldn't we call the method paint like obj.paint()?

As noted by MightyPork (1+ to him), the paint method is called by the JVM , and should not be directly called by you. You can suggest that it be called by calling repaint() , but you should almost never call it, or the paintComponent(...) method, directly.

---

Other issues:

• When painting in Swing, don't forget to call the super paint method within your own override. Otherwise the component will not do its own house-keeping painting, and you will break the painting chain, meaning components held by the painted container might not be painted correctly or at all.
• In general, you will want to not want to draw directly within a JFrame, since a JFrame is responsible for many key components, and if you messed something up, the GUI could be messed up.
• Much better would be to draw in a JPanel's paintComponent method, and then display that JPanel within your JFrame.
• Check out the tutorials for all the gory but very important details:
  • Lesson: Performing Custom Painting : introductory tutorial to Swing graphics
  • Painting in AWT and Swing : advanced tutorial on Swing graphics

---

Edit You ask:

So, when use API, we just "fill" with code the methods in the class, and the JVM will know when to call these methods?

Most often Swing graphics is "passive". Meaning you set your component up to be drawn a certain way, but you don't actively draw it yourself. Rather the JVM (the Java Virtual Machine -- the code that runs your Java program) does the drawing for you. If you want to do animation, often you'll change some positional variables, for instance xPosition and yPosition int variables, and then use those variables within your JPanel's paintComponent(Graphics g) method. So if you change the values held by these variables within a Swing Timer, and then call repaint() after the values have changed, the JVM will (usually) repaint your component, using the new values.

---

A more complex example that shows drawing in a JPanel, and shows a very simple animation:

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.*;

// draw in a JPanel, not a JFrame
public class SimpleAnimation extends JPanel {
   private static final int OVAL_WIDTH = 40;
   private static final int TIMER_DELAY = 50;
   private static final int PREF_W = 800;
   private static final int PREF_H = PREF_W;
   private int xPosition = 0;
   private int yPosition = 0;

   public SimpleAnimation() {
      // start my timer here
      new Timer(TIMER_DELAY, new TimerListener()).start();
   }

   @Override
   protected void paintComponent(Graphics g) {
      // call the super method so that the JPanel
      // can do its own house-keeping graphics first
      super.paintComponent(g);

      // I do this to so that my graphics are smooth 
      Graphics2D g2 = (Graphics2D) g;
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
            RenderingHints.VALUE_ANTIALIAS_ON);
      g2.setColor(Color.red);

      // use xPosition and yPosition to place my oval
      g2.fillOval(xPosition, yPosition, OVAL_WIDTH, OVAL_WIDTH);
   }

   // so our GUI will be big enough to see
   @Override
   public Dimension getPreferredSize() {
      if (isPreferredSizeSet()) {
         return super.getPreferredSize();
      }
      return new Dimension(PREF_W, PREF_H);
   }

   // class used by the Swing Timer to drive animation
   private class TimerListener implements ActionListener {
      @Override
      public void actionPerformed(ActionEvent e) {
         // change xPosition and yPosition
         xPosition++;
         yPosition++;

         // and call repaint
         repaint();
      }
   }

   // a method to be called in our Runnable
   private static void createAndShowGui() {
      SimpleAnimation mainPanel = new SimpleAnimation();

      JFrame frame = new JFrame("SimpleAnimation");
      frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
      frame.getContentPane().add(mainPanel);
      frame.pack();
      frame.setLocationByPlatform(true);
      frame.setVisible(true);
   }

   public static void main(String[] args) {
      // this is used to make sure that all Swing code
      // is started on the Swing event thread.
      SwingUtilities.invokeLater(new Runnable() {
         public void run() {
            createAndShowGui();
         }
      });
   }
}

Answer 2

You create the object new JavaGame() without assigning it to any variable, and that's it.

Swing render and event threads kick in and take care of the rest of the app's life.

I'm not sure why the Garbage Collector doesn't pick it up and end it, but I've done it this way for a long time and it works fine.

Answer 3

1. You don't need an object name. When you use new , the constructor will be called, which creates the frame.
2. Paint gets called whenever it needs to be. Check out this answer .