Is super()
used to call the parent constructor?
Please explain super()
.
The super keyword in Java is a reference variable which is used to refer immediate parent class object. Whenever you create the instance of subclass, an instance of parent class is created implicitly which is referred by super reference variable.
The super() function is used to give access to methods and properties of a parent or sibling class. The super() function returns an object that represents the parent class.
1) super is used to refer immediate parent class instance variable. We can use super keyword to access the data member or field of parent class. It is used if parent class and child class have same fields. In the above example, Animal and Dog both classes have a common property color.
Calling exactly super() is always redundant. It's explicitly doing what would be implicitly done otherwise. That's because if you omit a call to the super constructor, the no-argument super constructor will be invoked automatically anyway.
super()
calls the parent constructor with no arguments.
It can be used also with arguments. I.e. super(argument1)
and it will call the constructor that accepts 1 parameter of the type of argument1
(if exists).
Also it can be used to call methods from the parent. I.e. super.aMethod()
More info and tutorial here
Some facts:
super()
is used to call the immediate parent.super()
can be used with instance members, i.e., instance variables and instance methods.super()
can be used within a constructor to call the constructor of the parent class.OK, now let’s practically implement these points of super()
.
Check out the difference between program 1 and 2. Here, program 2 proofs our first statement of super()
in Java.
Program 1
class Base
{
int a = 100;
}
class Sup1 extends Base
{
int a = 200;
void Show()
{
System.out.println(a);
System.out.println(a);
}
public static void main(String[] args)
{
new Sup1().Show();
}
}
Output:
200
200
Now check out program 2 and try to figure out the main difference.
Program 2
class Base
{
int a = 100;
}
class Sup2 extends Base
{
int a = 200;
void Show()
{
System.out.println(super.a);
System.out.println(a);
}
public static void main(String[] args)
{
new Sup2().Show();
}
}
Output:
100
200
In program 1, the output was only of the derived class. It couldn't print the variable of neither the base class nor the parent class. But in program 2, we used super()
with variable a
while printing its output, and instead of printing the value of variable a
of the derived class, it printed the value of variable a
of the base class. So it proves that super()
is used to call the immediate parent.
OK, now check out the difference between program 3 and program 4.
Program 3
class Base
{
int a = 100;
void Show()
{
System.out.println(a);
}
}
class Sup3 extends Base
{
int a = 200;
void Show()
{
System.out.println(a);
}
public static void Main(String[] args)
{
new Sup3().Show();
}
}
Output:
200
Here the output is 200. When we called Show()
, the Show()
function of the derived class was called. But what should we do if we want to call the Show()
function of the parent class? Check out program 4 for the solution.
Program 4
class Base
{
int a = 100;
void Show()
{
System.out.println(a);
}
}
class Sup4 extends Base
{
int a = 200;
void Show()
{
super.Show();
System.out.println(a);
}
public static void Main(String[] args)
{
new Sup4().Show();
}
}
Output:
100
200
Here we are getting two outputs, 100 and 200. When the Show()
function of the derived class is invoked, it first calls the Show()
function of the parent class, because inside the Show()
function of the derived class, we called the Show()
function of the parent class by putting the super
keyword before the function name.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With