Re: Parent Class non parametrized Constructor Invoked even if am
not invoking super() constructor from Child Class
Ados wrote:
I have 3 classes student, onlinestudent which extends student class
and RunStudent class which has main method,
...
--------------------------------------------------------------------
package Student;
By convention, package names are spelled in lower-case
public class student {
and class names with an initial upper-case letter.
public int Age;
public int RollNo;
public char Name;
Variable and method names should begin with a lower-case letter.
All names should be spelled with "camel case" - compound word segments other
than the first one begin with an upper-case letter, such as with your
'OnlineStudent' class.
Now on to your main question.
public student() {
System.out.println("No Parameter Student Constructor");
};
Actually, the correct term is "no-argument" ("no-arg") constructor.
....
My Question:
If I am creating object instance of OnlineStudent class than why non
parametrized
public student(){
System.out.println("No Parameter Student Constructor");
}
is invoked even if I am not explicitly invoking it.
Because if you don't provide an explicit 'super()' call, the compiler adds one
for you, and the implicit 'super()' call is always the no-arg constructor.
2nd Question:
When I change non parameterized public student() to parametrized
public student(int a, int b) than I get compilation error at
public OnlineStudent() { //
student() is not defined implicitly and so explicitly define it
Your wording is confusing, but I think I understand what you're saying.
You're saying that you got rid of the no-arg constructor in the 'student'
(should be 'Student') class, correct?
Please quote *exact* error messages, not mangled paraphrases.
public OnlineStudent(int webid, int netid){ //student
() is not defined implicitly and so explicitly define it
System.out.println("Parameter OnlineStudent Constructor");
};
why do I get this error.
Because you did not have a no-arg constructor for the parent class. When the
child class tried (implicitly) to invoke the no-arg 'super()' constructor,
there wasn't one to invoke, and voil?, compiler error. The method or
constructor you invoke has to exist.
3rd Question:
If we have defined any parametrized constructor then nonparametric
constructor let's say default constructor are needed or its ok if we
do not have them ?
First of all, terminology: the no-arg constructor is only the "default"
constructor if you let the compiler define it for you. If you provide *any*
constructor yourself, you do not get a default constructor. Thus you would
have to define a no-arg constructor yourself, in addition to the one that
takes arguments.
Since you define a constructor that takes arguments, the compiler does not
automatically define a no-arg constructor for you, therefore you do not have a
no-arg constructor unless you define it explicitly.
When we define any constructor then we do not get the default
constructor that is nonparametric constructor, am I right or not ?
s/nonparametric/no-argument/
If you provide a no-argument constructor yourself, then you will have one no
matter how many other constructors you also have. Thus, if you had a
'Student' class with two constructors:
public Student() { ... }
and
public Student( char a, char b ) { ... }
then a child class of 'Student' that calls 'super()' (no-args) from its
constructor will not have that compiler error, because the parent class no-arg
constructor will exist.
Summary:
If you provide no explicit constructor for a class, the compiler provides an
implicit "default constructor" that takes no arguments.
If you provide any explicit constructor, the compiler will not provide a
default constructor. If you need a no-arg constructor in that case, you have
to write it.
If you do not start a constructor with 'this()' (with or without arguments) or
'super()' (with or without arguments), the compiler provides an implicit first
call to 'super()' with no arguments.
Any constructor 'this()' or 'super()' call, implicit or explicit, with or
without arguments, must refer to a constructor that actually exists.
<http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.8>
<http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.8.8>
<http://java.sun.com/docs/books/jls/third_edition/html/classes.html#8.8.9>
--
Lew