Thread: Inheriting Applet and paint() GUI Method Logic?

1. Whenever you write "extends Applet", you're inheriting the Applet class's methods and stuff. It's because you've basically, with that phrase, turned your class into a subclass of Applet. A subclass represents an "is-a" relationship - that is, your class IS an Applet, and thus inherits all of Applet class's methods.

2. If you were just writing some random class of your own that didn't extend anything, then writing "public void init()" would indeed be making your own method. But when your class extends Applet, it inherits all of Applet's methods, including a method called init(). This method is called whenever the webpage containing the applet is loaded. When you then write "public void init()", you aren't making your own method, but you aren't calling a method either - you are overriding the Applet class's method. That basically means that when something else calls your class's init() method, the actual method that gets called is the one you wrote, not the one you inherited.

Init() is called when the Applet is displayed. Normally - well, who cares what it doe by default. You have overriden it so that it does whatever you wrote in your code that you want it to do.

Paint() is the same deal. The paint() method is called whenever a GUI component is displayed. basically, that means it is called when you run the program. Normally, this might just be a white box or something. However, you can OVERRIDE the paint method by writing your own in a class that extends JPanel or JComponent or some other class that already has a paint method.

It seems that you're a little confused about inheritance. Here's a hopefully clearer explanation:

Say you have a class named ClassA. Then, you write a ClassB, which extends ClassA. ClassA has a method called printStuff().

public class ClassA{
public void printStuff(){
System.out.println("Hello world");
}
}

public class ClassB extends ClassA {
}

Now, in the above, ClassB is empty. However, even though there's nothing written in ClassB, it's not actually empty. It does have one method, called printStuff(), which it inherits from ClassA. Thus, if you did this:

ClassB bbb = new ClassB();
bbb.printStuff();

It would work even though nothing is written in ClassB. The runner first looks for the method in the subclass (ClassB). Not finding it, it goes up one level, and, sure enough, finds it in the superclass (ClassA), and calls it.

What if we rewrite ClassB like this?

public class ClassB extends ClassA {
public void printStuff(){
System.out.println("Goodbye");
}
}

Now, when you create bbb and call printStuff(), it prints "Goodbye". The method has been overridden. When the runner calls a method, it looks from the bottom up: first at the subclass, and then at the superclass. If it finds the method in the subclass, it calls it there. If not, then it calls it in the superclass. This is an important concept about inheritance.

Why? Well, think about it: it actually does make the whole displaying graphics thing easier. When you display an applet or any graphics of any kind, a lot of stuff goes on behind the scenes to make those pictures appear that you don't have to think about. Every applet has an init() method, and it's the init() method that is called when it's displayed. If it didn't have an init() method, things would go wrong. Applet has an init() method, and therefore everything that extends Applet does too, even if you don't write one in. And if you don't want the white block or whatever the default init() method gives you, you can just override it to do whatever you want.