Java Super Keyword
In Java, the super
keyword is a reference variable that is used to refer to the object of the immediate parent class.
When you create a subclass instance, an implicit instance of the parent class is also created and is referred to by the super reference variable.
The super
keyword is used to
- Access the variable of the parent class instance.
- Invoke the method of the parent class.
- Invoke the constructor of the parent class.
Access the variable of the parent class instance
We can use the super
keyword to access and use the parent class variable.
Example to access parent class variable with super keyword
class Animal {
String color = "black";
}
class Cat extends Animal {
String color = "white";
void PrintCatColor() {
System.out.println("Cat Color: "+color);
System.out.println("Animal Color: "+super.color);
}
}
class Main {
public static void main(String args[]) {
Cat cat = Cat Dog();
cat.PrintCatColor(); // Dog Color: white
// Animal Color: black
}
}
The above program has a class Animal
with a variable color
with default value black
. The Animal
class is inherited by the Cat
class which also has the variable color
with default value white
.
The PrintCatColor()
method will print the value in color
variable of Cat
class and to print the Animal
class variable value of color
we use super.color
.
When we create an object for the Cat
class and call the PrintCatColor()
method we get the following output
Cat Color: white
Animal Color: black
Invoke the method of the parent class
Using the super
keyword we can access the method of the parent class.
Example for invoking the method of parent class
class Animal {
public void Category() {
System.out.println("I'm an animal");
}
}
class Cat extends Animal {
public void Type() {
System.out.println("I am a cat.");
}
public void Behavior() {
super.Category();
Type();
}
}
class Main {
public static void main(String[] args) {
Cat cat = new Cat();
cat.Behavior();
}
}
In the above program, the Animal
class has a method Category()
and this Animal
class is inherited by the Cat
class.
The Cat
class has 2 methods Type()
and Behavior()
.
In the Behavior()
method we call the Category()
method of the Animal
class using super.Category()
and Type()
method.
Next, we create an object for the Cat
class and call the Behavior()
function. It will display the following output
I'm an animal
I am a cat.
Invoke constructor of parent class
Sometimes we need to invoke the constructor of the parent class. In such situation we use super()
method to call the immediate parent class constructor.
class Animal {
// Animal class constructor
Animal() {
System.out.println("Animal Category");
}
}
class Cat extends Animal {
Cat() {
super(); // Call the Animal(parent) class constructor
System.out.println("I am a Cat");
}
}
class Main {
public static void main(String[] args) {
Cat cat = new Cat();
}
}
The above program is an example for calling the constructor of the parent class.
Here, the Animal
class has a constructor and this class is inherited by the Cat
class.
The Cat
class contains a constructor. Inside the constructor we will call the constructor of the Animal
class using super()
method.
Now when we create an object for the Cat
class, the output will be,
Animal Category
I am a Cat
Real-world example where the super keyword is used
class Employee {
String empId;
String name;
Employee(String name, String empId) {
this.empId = empId;
this.name = name;
}
}
class Developer extends Employee {
float salary;
Developer(String empId, String name, float salary) {
super(empId, name); // Call the Employee Constructor
this.salary = salary;
}
void Display() {
System.out.println("Employee Id: " + empId);
System.out.println("Employee Name: " + name);
System.out.println("Employee Salary: " + salary);
}
}
class Main {
public static void main(String[] args) {
Developer emp = new Developer("Emp001", "Andrew", 60000 f);
emp.Display();
}
}
In the above program, we have created a class Employee
to have the common details of employee of any category. Here it contains the empId
and name
variable.
Next, we create a class Developer
which inherits the Employee
class. The Developer
class has a parameterized constructor with empId
, name
and salary
.
The Developer
class constructor, then calls the super()
method and invokes the Employee
class constructor to initialize the value of empId
and name
variable.
Later, in the Main
class we create an object for the Developer
class with the parameters and call the Display()
method of the class to display the details of the developer as below.
Employee Id: Andrew
Employee Name: Emp001
Employee Salary: 60000.0