This post will focus on the concepts surrounding Constructors in Java. So, here we go...
- Constructors MUST have the same name as class.
- A constructor is invoked when an object is created.
- Constructors don't have a return type.
- Interfaces never have constructors.
- Constructors cannot be inherited, thus they cannot be overridden.
- Constructors can use any access modifier.
- The compiler will create a default constructor, even if you don't create one yourself.
- Every class has a constructor. Even an abstract class has one.
- The default constructor is a no-arg constructor with a call to super().
- The constructor can be directly invoked using another constructor only i.e using a call to super() or this().
- Calls to this() or super() cannot be in the same constructor. Either one can exist, not both.
- this() may appear as only the first statement in a constructor.
- Constructors can call other constructors and they can call constructors again, however it's advisable to use a call to super() as early as possible to avoid the explosion of stack.
- The call to super() can be a no-arg call or may have arguments passed to the super constructor.
- Its perfectly legal to have methods and constructor with the same name and in the same class. However it's not considered to be a good programming style.
class Foo {
Foo() {} // this is the constructor.
}
In this case, when the compiler compiles it, it generates a default constructor. So, for the compiler, the above code will look like:
class Foo {
Foo {
super();
}
}
No comments:
Post a Comment