Superclass and subclass

Question

Ok I have now reached the area of using Superclass and subclass in my
self study of Java, and I am stumped on what is I am sure is a very
easy concept. Here's the Scenerio. I have three classes Point, Circle
and InheritanceTest. Point is the Superclass that is being referenced
from Circle InheritanceTest has the main Method.
Inside the Point class the book I am using has this note inside the
constructor.
public void Point{
//implicit call to superclass constructor occurs here
setPoint(0,0);
My question is this, Is the call to it's self or the object class?
And do you Know which one it is referring to?
Thanks in advance

Answer 1

public void Point{
//implicit call to superclass constructor occurs here
setPoint(0,0);
}When you extend a class, every constructor of the new class must call a constructor of the extended class- this is done by using super() or super(some arguments). Note that if you don't put this in, java will implicitly call super() for you- it basically inserts this call into your new constructor.
As for the setPoint() method, if your new class has a method of this name and signature (i.e. same type of arguments), it will call your sub-class's method. If the sub-class does not have a method like this defined, it will look for this method in the super-class and call that one. In this way, you are inheriting the methods of the super-class. Unless you specifically override a method (give a method of the same name in type in the sub-class as in the super-class), all public or protected methods of the super-class can be used as if they were methods of your sub-class.
Check this out:
public class SuperClass
     private int value = 0;
     public SuperClass()
          super();
          // Calling the default constructor of Object, the superclass of this class
     public SuperClass(int value)
          // Implicitly calling super() since a superclass constructor was not given explicitly
          this.value = value;
     public int getValue()
          return value;
     public void setValue(int value)
     this.value = value;
     public void changeValue()
          setValue(getValue() + 1);
public class SubClass
     public SubClass()
          super(0);     // Calls the SuperClass(int) constructor
     public SubClass(int value)
          // Implicit call to SuperClass() constructor
          setValue(value);
     public void changeValue()
          // Overrides the SuperClass method of the same name
          setValue(getValue() - 1);
     public void useSuperChangeValue()
          super.changeValue();     // Calls SuperClass.changeValue()
     // If you want to use the super-class methods, even if they have been overridden,
     // use the keyword "super" to reference the superclass