CODEWITHSUNDEEP
javaobject
Willis
Willis

Reputation: 11

Can't run paint method from main method

In the main method, I am trying to run this:

public static void main(String[] args)
{
    game.paintBlocks(g);
}

And getting a "cannot be resolved to variable" error for the "g" parameter.

Elsewhere I have this, which calls on another method in another class (paint(g)) to paint a grid of blocks:

public void paintBlocks(Graphics g)
{  
    for (int r = 0; r<7; r++)
    {
        for (int c = 0; c<5; c++)
        {
            block[r][c].paint(g);
        }
    }

Do I need to tell it that "g" is in another class? I'm new to this and any help would be awesome!

Upvotes: 1

Views: 5621

Answers (3)

Feanor
Feanor

Reputation: 2725

In the case of paintBlocks, g is a parameter that is being passed in to the method. In the case of main, g is referencing a variable that hasn't been created anywhere.

Graphics and Graphics2D are abstract classes, and aren't generally intended to be instantiated except by Swing. What Graphics and Graphics2D give you is a context for drawing on a component (like a JPanel or a BufferedImage).

Based on your description you probably want to draw blocks on a Swing component of some kind. (Though it's a little unclear, that would be a normal kind of thing to do.) What you would normally want to do if you are drawing the blocks on a JPanel, for example, is to create a class that extends JPanel and override the paintComponent() method. One way you might do that:

public class BlocksPanel extends JPanel {
   // Normal class fields, etc.
   // ...

   // I would consider making this private, but this is your method from above:
   public void paintBlocks(Graphics g) {  
      for (int r = 0; r<7; r++) {
         for (int c = 0; c<5; c++) {
            block[r][c].paint(g);
         }
      }
   }

   @Override
   public void paintComponent(Graphics g) {
      paintBlocks(Graphics g);
   }
}

There is another example that might help you on page 9 of this document. The Java Tutorials for the Java 2D API may also help.

Upvotes: 1

avh4
avh4

Reputation: 2655

Where do you want to paint to? I'm assuming you probably want to paint to a window on the screen, in which case you won't be calling paint* yourself, you'll let the Swing framework call it at the appropriate times. In this case, if game is a JFrame, then you just need to make it visible; or if game is some other type of component then you'll need to add it to a visible window. This is the pattern I normally use when I'm teaching basic graphics in Java:

public class MyGame extends JPanel {
  public static void main() {
    JFrame window = new JFrame("My Game");
    window.add(new MyGame());
    window.pack();
    window.setLocationRelativeTo(null); // Centers the window on the screen
    window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    window.setVisible();
  }
  public Dimension getPreferredSize() {
    return new Dimension(800, 600);
  }
  protected void paintComponent(Graphics g) {
    // Do my drawing here
  }
}

If you want to paint to an off-screen image, then you'll need to create your own graphics context to pass to the paint* methods:

BufferedImage hello = new BufferedImage(game.getWidth(), game.getHeight(), BufferedImage.TYPE_INT_ARGB);
Graphics g = hello.getGraphics();
game.paintBlocks( g );

Upvotes: 1

DaMainBoss
DaMainBoss

Reputation: 2003

The variable g is undefined in the main context because you havent declared/initialised it. If you look at your paintBlocks(Graphics g) method, g is passed as a parameter, however the scope of that variable(g) is within the braces({}) of the method paintBlocks(Graphics g).

If you have a class called MyClass that extends a Component, say JPanel, you can do something like this:

class MyClass extends JPanel
{
     public static void main(String[] args)
     {
         Graphics g = getGraphics(); //would return the graphics object for the JPanel
         game.paintBlocks(g);
     }
}

Its also good to note that the above method in some cases would be tagged as bad programming style. There is an alternative. You can make use of the paintComponent(Graphics g) method provided by the component.

Your main would then look like this:

public static void main(String[] args)
{
   repaint(); //this repaints the component, calling the paintComponent method
}

Its also bad programming style to call paintComponent(Graphics g) yourself. You should allow your system to call that method and thats why you have the repaint() method. The system automatically invokes paintComponent(Graphics g) when you repaint.

From paintComponent(Graphics g) you can then do this:

public void paintComponent(Graphics g)
{
    super.paintComponent(g); //repainting the panel,not necessary in some cases
    game.paintBlocks(g); //passing the graphics object used by the component
}

Hope that helped!

Upvotes: 0

Related Questions