Question on Constructor

[RUI CHEN]

Like:
class par{
par(int i){}
}
class chi extends par{
chi(){}
}
the program will fail when compiling and says a "cannot resolve symbol constructor par()".
i know that there won't be a default non arugement constructor created for chi in this case. however, why such a strange thing will happen even i created one constrcutor for the chi?
besides, no matter the function chi() has argument or not, the compiler all works like that.
.........who could tell me why?

[Shishio San]

you need to define a default constructor in the parent class.

[Barry Gaunt]

As Shishio San has said you must explicitly declare a no-arguments constructor for class par.
When an instance of class chi is created its constructor chi() is called. But class chi is a subclass of class par so a constructor of class par must be called. Because you have not called the class par constructor yourself the compiler tries to call the par() (it does this by doing super())constructor for you. But there isn't one, because you only provided par(int). Remember: if you provide a constructor for a class the compiler will not provide a no-argument constructor automatically. If you do not provide any constructors the compiler will supply a default no-argument constructor.
-Barry
[ December 22, 2002: Message edited by: Barry Gaunt ]

[Roan Nicolas]

Hi Rui,
Remember the super() construct leads to chaining of subclass constructors to superclass constructors. This means that a subclass must call the constructor of its superclass. This chaining behavior guarantees that all superclass constructors are called starting from the Object class, followed by the constructors in the other classes down to the class being instantiated. This is called (subclass-superclass) constructor chaining.
If a constructor does not have an explicit call to super(), then the call super() (without the parameters) is implicitly inserted to invoke the default constructor of the superclass.
If a class only defines non-default constructors (i.e. only constructors with parameters) then its subclasses cannot rely on the implicit behavior of a super() call being inserted. Subclasses must then explicitly call a superclass constructor, using the super() construct with the right arguments. In your case:
class par{
par(int i){}
}
class chi extends par{
chi(){
super(5) //insert this code
}
Hope that makes sense
}

[RUI CHEN]

Thank you so much, Shishio,Barry and Roan!!!
I will remember it, "constructor chaining".

[Kathy Sierra]

Howdy -- just wanted to clarify a couple of little terminology things
For constructor chaining, we actually say that constructors are CALLED from the bottom up, but COMPLETE from the top-down. So constructor chaining doesn't exactly start from the top, at Object, although Object is the first to actually complete. Constructor chaining puts the constructors on the stack starting with the class you said "new" on. So if you say new Dog(), the Dog constructor first goes on the stack. Then, the immediate superclass constructor (Animal()) is invoked (using the call to super()) and then the next superclass, etc. all the way up to Object. So Object's constructor is the LAST to be invoked (it's at the top of the stack), but it is the FIRST to actually complete. Then once it completes it is popped off the stack and the next highest class in the inheritance tree runs IT'S constructor, and so on until you get to the bottom -- the constructor that was first invoked.
Here's one way to remember it...
Your parents have to be born FIRST, before YOU can be born. Java doesn't really violate the fundamentals of biology. Well, not completely. Then again, you can only have one parent... oh well, we won't go there ; )
And one other thing:
We make a distinction between the "default" constructor and a "no-arg" constructor. The default constructor is the one the compiler puts in, which happens to be a no-arg constructor. But if you write one yourself, we say that you wrote a no-arg constructor, not a default constructor. The default constructor is the one you get if you don't write any constructors at all.
Cheers,
Kathy
Author, "Cowgirl's guide to no-arg relationships"