Sun Tutorial: LoadImageApp

Newbie & Debugging Questions
#1 

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.io.*;
import javax.imageio.*;
import javax.swing.*;

/**
 * This class demonstrates how to load an Image from an external file
 */
public class LoadImageApp extends Component {
          
    BufferedImage img;

    public void paint(Graphics g) {
        g.drawImage(img, 0, 0, null);
    }

    public LoadImageApp() {
       try {
           img = ImageIO.read(new File("knight.png"));
       } catch (IOException e) {
       }

    }

    public Dimension getPreferredSize() {
        if (img == null) {
             return new Dimension(100,100);
        } else {
           return new Dimension(img.getWidth(null), img.getHeight(null));
       }
    }

    public static void main(String[] args) {

        JFrame f = new JFrame("Load Image Sample");
            
        f.addWindowListener(new WindowAdapter(){
                public void windowClosing(WindowEvent e) {
                    System.exit(0);
                }
            });
        f.add(new LoadImageApp());
        f.pack();
        f.setVisible(true);
    }
}

I do not understand what the following line means:

 f.add(new LoadImageApp());

LoadImageApp() is void, isn’t it? So what does “new LoadImageApp()” return?
How do I remove the image from JFrame f again?

#2

By calling “new,” it means you are creating a new object. The parameters afterward are dependent upon the constructor allowed.

Example:


public class Test
{
     public Test()
     {
          //Blah
     }

     public Test(int x)
     {
          //blah
     }

     public Test (int x, int y)
     {
          //blah
     }

     public void doSomething()
     {
          //blah
     }
}

If I want to create a new Test object, then I can say one of the following:


Test a = new Test();
Test b = new Test(5);
Test c = new Test(1,2);

Those would call the respective constructors that match the number and type of parameters given. Constructors have no return type - they are not void. In addition, they must match the name of the class they are contained in. Notice they all say Test.

A method that is void is doSomething(). Notice the difference - it has “void” written there. So, I couldn’t do this:


//not allowed:
int i = a.doSomething();

Because doSomething() doesn’t return anything.

#3

Sorry, void is a wrong expression. What I mean is, that LoadImageApp() doesn’t return anything. But if it doesn’t return anything, and f.add() expects something to be added to the JFrame, how does the system ensure that my program actually knows what I want to be added to the frame?

f.add(new LoadImageApp());
#4

Hi.

LoadImageApp() is the constructor, and invoking a constructor with the new keyword gives you a new instance(object) of the class LoadImageApp.

Consider this:

LoadImageApp myLoader = new LoadImageApp();
f.add( myLoader );

This is equivalent to your line, - you’re just saying you dont need a direct reference to your instance.

f.add(new LoadImageApp());

To fully understand, google “Constructor”, or look here for instance:

http://www.ccnyddm.com/AdvJava/java_constructor_tutorial.htm

#5

Yeah, that’s what I meant by “Constructors have no return type - they are not void. In addition, they must match the name of the class they are contained in. Notice they all say Test.” You will have a public method with no return type that is called the same thing as the class, and that will always be your constructor that comes into play whenever someone uses “new.”

#6

Thank you, but these are not the answers that I expected. I know what a constructor is… Let me explain it again:

I took the previous code and replaced

    public LoadImageApp() {
       try {
           img = ImageIO.read(new File("knight.png"));
       } catch (IOException e) {
       }

with

    public LoadImageApp() {
       try {
           img = ImageIO.read(new File("knight.png"));
           img2 = ImageIO.read(new File("squire.png"));             <==
       } catch (IOException e) {
       }

.

One might expect that the program now adds TWO images instead of one. But it doesn’t! It still shows only one - the first one. So how does it know that I want it to display this one and not the other one, or even both of them? That’s why I thought that there must be some kind of return value. How does it work? How does add() know that it shall take “img” instead of “img2”?

#7

I did another test replacing…

    public void paint(Graphics g) {
       g.drawImage(img, 0, 0, null);
    }

with

    public void paint(Graphics g) {
        g.drawImage(img, 0, 0, null);
        g.drawImage(img2, 0, 0, null);
    }

And now both images are shown! Does “setVisible()” call my “paint()” function!?

#8

First you say you know constructors, but you seem puzzled by the way the simplest code behaves.

I’d advice you to first learn Java (maybe by working with UML schemes, or heck, a good book…).

Java itself is hard enough. Trying to learn Java and user interfaces at the same time, will make your head hurt.

I understand it’s very rewarding to see an Image being painted on the screen by a program that you wrote, but you won’t get much further than that with some trial-and-error hacking. Try to first understand what you’re doing, by staring small. Let System.out and System.in be your friend for the first few months.

#9

In your first post (3 posts ago), you are creating the actual images. In your second post (2 posts ago), you are actually drawing them. With just the first post’s code, you can create 500 images that way and none of them will be drawn unless you actually draw it.

Think of having 500 paint cans. You might have all the colors you need to create the Mona Lisa, but you’ve got actually put down the paint in order to show it.

#10

Okay, it’s as I suspected: paint() is called by setVisible(). That’s why I initially couldn’t figure out how the system works… But now its perfectly clear to me. Thanks. :slight_smile:

I for myself prefer this trial-and-error method. In my opinion, it’s far more interesting to simply start working on a game than reading boring books and tutorials. Only if I get stuck, do I try to find a solution. In my experience, that’s the most efficient way of learning.

#11

Well, in my opinion, trial and error is certainly an option when coding, but only once you know enough that most of the trials don’t turn into errors. In all other cases you need to study the problem with some background info / documentation / tutorials / browsing sourcecode.

#12

I tried to post this a while ago but the forum bugged out on me.

Ahh, yes, the whole hierarchy of Java2D drawing methods is a bit confusing.

setVisible() does not call paint - your window calls paint when it is first created. In order to convey any graphic updates, you’re going to want to call repaint() every time you change something. But you probably don’t want to use paint(). Instead, override paintComponent() and put all drawing in there.


public void paintComponent(Graphics g)
{
     //Do default stuff like draw the background and refresh the canvas.
     super.paintComponent(g);

     //Do your drawing here:
}

As for your method of learning, I agree that you will learn significantly more with the hands-on approach. However, you’re going to have huge gaps in your knowledge unless you have some book or teacher to work alongside with you. I would get a book and use it as reference as you go.

#13

“But you probably don’t want to use paint(). Instead, override paintComponent() and put all drawing in there.”

That’s right, I don’t use paint() by myself. But refresh() calls it for me. In order to redraw the screen, all I have to do is typing “MyFrame.refresh()”. That’s quite comfortable, I think. I do not understand why I should override paintComponent(). What’s the intention/advantage of doing so?

“Well, in my opinion, trial and error is certainly an option when coding, but only once you know enough that most of the trials don’t turn into errors. In all other cases you need to study the problem with some background info / documentation / tutorials / browsing sourcecode.”

Yes, you are right. I forgot to mention that I already have some experience in C++ and in other languages as well. So programming in general isn’t new to me. All I have to do is getting familiar with the subtleties of Java. Some of them - especially the fact that there are no pointers in Java - are quite irritating to me at the moment. And that might be the reason why it seems to you that I’m “puzzled by the way the simplest code behaves”.

#14

I’m not sure for the exact technical reason, but typically you override paintComponent() when drawing with Swing.

Also, you mean MyFrame.repaint() I believe.

#15

paint() is part of java.awt.Component
paintComponent is part of javax.swing.JComponent

paint() calls paintComponent, and a bunch of other stuff, like paintBorder

so if you override paint() your border will be gone (if any) among other things.

#16

There’s the reason. :stuck_out_tongue:

One of those places where I learned what to do but never bothered to check why. ;D