Super Keyword in Java

Super Keyword in Java

6 mins read7K Views Comment
clickHere
Updated on Apr 12, 2023 12:42 IST

This Java Tutorial article covers one of the most important concepts in Inheritance which is Super Keyword in Java. Here, we’ll go through the uses of super keyword along with examples.

2022_06_super-keyword.jpg

The super keyword in Java is a reference variable a subclass uses to access the object of its immediate parent class. It allows the subclass to access the parent class’s data members (variables, methods, and constructors). The super keyword is used to access the parent class object and is based on the concept of inheritance in Java. It is important to note that the super keyword can only be used inside a subclass and not in a top-level class or interface.

Contents

Why do we need a Super keyword in Java?

There are several reasons why we might need to use the super keyword in Java:

  1. Access the members of the superclass from within the subclass:
  2. Invoke the superclass constructor from within the subclass constructor.
  3. Resolve ambiguity between a field or method in the subclass and a field or method in the superclass.
  4. Access the static members of the superclass from within the subclass.

Example of Super Keyword in Java

 
// Superclass definition
class Animal {
// Field to store the animal's name
protected String name;
// Constructor to initialize the animal's name
public Animal(String animalName) {
name = animalName;
}
// Method to display the animal's name
public void displayName() {
System.out.println("Animal's name: " + name);
}
}
// Subclass definition that extends the Animal superclass
class Cat extends Animal {
// Field to store the cat's breed
private String breed;
// Constructor to initialize the cat's name and breed
public Cat(String animalName, String catBreed) {
// Call the superclass (Animal) constructor
super(animalName);
// Initialize the cat's breed
breed = catBreed;
}
// Method to display the cat's name and breed
public void displayInfo() {
// Display the cat's name using the super keyword
super.displayName();
// Display the cat's breed
System.out.println("Cat's breed: " + breed);
}
}
class Main {
public static void main(String[] args) {
// Create an object of the Cat class
Cat c = new Cat("Fluffy", "Siamese");
// Display the cat's name and breed
c.displayInfo();
}
}
Copy code

In this example, the Cat subclass extends the Animal superclass and overrides the displayInfo method to display the cat’s name and breed. The displayInfo method calls the displayName method of the Animal superclass using the super keyword and then displays the cat’s breed. When the displayInfo method is called on the c object of the Cat class, it displays the following output:

Output:

 
Animal's name: Fluffy
Cat's breed: Siamese
Copy code

Uses of Super Keyword in Java

Following are the uses of Super Keyword in Java:

Access Superclass Data Members (or Variables)

Using a super keyword with the same name as data members (variables) in the superclass and subclass can help you access the superclass variables without getting shadowed by its subclass.

Let’s see an example demonstrating the use of the super keyword in Java to access superclass’ same-name data members (variables).

Example:

 
// SuperClass definition
class SuperClass {
// Declare a variable
int variableA;
// Constructor to initialize the variable
SuperClass() {
variableA = 5;
}
}
// SubClass definition that extends the SuperClass
class SubClass extends SuperClass {
// Declare a variable
int variableB;
// Constructor to initialize the variable
SubClass() {
// A call to superclass variable variableA
variableB = super.variableA * 2;
}
// Method to display the values of the variables
void displayVariables() {
System.out.println("The value of variable variableA in superclass SuperClass: " + super.variableA);
System.out.println("The value of variable variableB in subclass SubClass: " + variableB);
}
}
// Main class
class Main {
public static void main(String[] args) {
// Create an object of the SubClass
SubClass obj = new SubClass();
// Call the displayVariables method
obj.displayVariables();
}
}
Copy code

Explanation:

In this code, the SuperClass defines a variable variableA and a constructor that initializes the variable to 5. The SubClass extends the SuperClass and defines a variable variableB and a constructor that initializes the variable to twice the value of variableA in the SuperClass. The SubClass also defines a method displayVariables that displays the values of variableA and variableB.

In the main method of the Main class, an object of the SubClass is created, and the display variables method is called to display the values of variableA and variableB. The output shows the values of the variables in the SuperClass and SubClass.

Output:

 
<strong>The value of variable variableA in superclass SuperClass: 5
The value of variable variableB in subclass SubClass: 10
</strong>
Copy code
Constructors in Java Explained
Constructors in Java Explained
In Java, constructors initialize newly created objects, setting their initial state. They share the same name as the class, lack a return type, and are automatically invoked upon object instantiation.
Final Keyword in Java
Final Keyword in Java
The Final Keyword in Java allows declaring a class, data members, and methods to unalterable and behaves differently when it is used with classes, methods, and variables. In this article,...read more
An Introduction to “this” Keyword in Java
An Introduction to “this” Keyword in Java
The article below explains the usage of this keyword in java with suitable examples and descriptions.

Using Superclass Member Functions (or Methods)

The subclass can use the super keyword to access is used to access methods (same name) from its superclass.  

The below examples demonstrate the use of the super keyword. Here the method display is defined in both parent and subclass. Notice how super keywords help in accessing the member functions (or methods) of the superclass (Quadrilateral) from subclass (Rectangle).

Example:

 
// Superclass definition
class QuadrilateralShape {
// Method to display the shape type
public void displayShapeType() {
System.out.println("I am a Quadrilateral");
}
}
// Subclass definition that extends the Superclass
class RectangularShape extends QuadrilateralShape {
// Method to display the shape type
public void displayRectangleType() {
System.out.println("I am a Rectangle");
}
// Method to display the shape types
public void displayShapeTypes() {
// This calls the subclass method (overriding method)
displayRectangleType();
// This calls the superclass method (overridden method)
super.displayShapeType();
}
}
class Main {
public static void main(String[] args) {
// Create an object of the RectangularShape class
RectangularShape r = new RectangularShape();
// Call the displayShapeTypes method
r.displayShapeTypes();
}
}
Copy code

Explanation:

The above code defines a superclass QuadrilateralShape with a method displayShapeType that displays the type of shape. It also defines a subclass RectangularShape that extends the QuadrilateralShape class and overrides the displayShapeType method with a new implementation that displays the type of rectangle.

The RectangularShape class also defines a method displayShapeTypes that calls the displayRectangleType method, which is the overriding method in the subclass, and the displayShapeType method, which is the overridden method in the superclass.

In the main method of the Main class, an object of the RectangularShape class is created, and the displayShapeTypes method is called to display the type of rectangle and the type of quadrilateral. The output shows the type of rectangle and the type of quadrilateral.

Output:

 
I am a Rectangle
I am a Quadrilateral
Copy code

Also, Read: Java Operators Explained

Calls Superclass Constructor

As we know by the concept of Constructors in Java, a default constructor is automatically called whenever the respective object of the class is created. However, calling a superclass constructor from the subclass seems impossible regarding inheritance. 

Here comes the super keyword to the rescue; it helps to call the superclass constructor from a subclass. 

Let’s see how does it work?

Example:

 
// Superclass definition
class Shape {
// Declare variables to store the dimensions
double dimension1, dimension2;
// Superclass (Shape) constructor
Shape(double dim1, double dim2) {
dimension1 = dim1;
dimension2 = dim2;
}
// Method to calculate the area of the shape
double calculateShapeArea() {
return dimension1 * dimension2;
}
}
// Subclass definition that extends the Superclass
class RectangularShape extends Shape {
// Subclass (RectangularShape) constructor
RectangularShape(double length, double breadth) {
// Call the superclass (Shape) constructor
super(length, breadth);
}
}
class Main {
public static void main(String[] args) {
// Create an object of the RectangularShape class
RectangularShape r = new RectangularShape(5, 8);
// Calculate and display the area of the shape
System.out.println("Area: " + r.calculateShapeArea());
}
}
Copy code

Explanation:

The calculateShapeArea method of the RectangularShape class produces this output. The method calculates the area of the shape using the dimensions dimension1 and dimension2, which are passed to the RectangularShape constructor. Dimension 1 and dimension 2 are initialized to 5 and 8, respectively. Finally, calculate the shape’s area by multiplying these dimensions, resulting in a value of 40.0.

Output:

 
Area: 40.0
Copy code

Read: Implementing Array in Java

Conclusion

The above article goes through various uses and implementations of super keywords in Java using examples. We hope the tutorial helped you understand the super keyword better. In addition, if you have any queries, please ask us on the link below and stay tuned for more content on Java Programming.

For more, Read: 8 Most Important Data Structures a Programmer Must Know.

FAQs

When to use super keyword in Java?

1. To access the members of the superclass from within the subclass: We can use the super keyword to access the members of the superclass that have been overridden or hidden by the subclass. 2. To invoke the superclass constructor from within the subclass constructor: When we create a subclass, we can use the super keyword to call the constructor of the superclass, passing the required arguments. This is done to initialize the instance variables of the superclass before initializing the instance variables of the subclass. 3. To resolve ambiguity between a field or method in the subclass and a field or method in the superclass: If a subclass has a field or method with the same name as a field or method in the superclass, we can use the super keyword to specify which field or method we want to access. 4. To access the static members of the superclass from within the subclass: We can use the super keyword to access the static members of the superclass from within the subclass.

How does the super keyword help superclass from getting overridden?

The super keyword does not directly prevent the superclass from being overridden. However, if we use the final keyword to make a method or class final, it cannot be overridden or subclassed.

Where can we use the super keyword in Java?

The super keyword in Java is a reference variable that is used to refer to the immediate superclass of a class. It can be used to access the members (fields, methods, and constructors) of the superclass from within the subclass. The super keyword is an important part of object-oriented programming in Java and is used to allow subclass objects to access the members of their superclass and to allow subclass constructors to initialize the instance variables of their superclass.

What is Super Keyword in Java?

The super keyword in Java is a reference variable that is used to refer to the immediate superclass of a class. It can be used to access the members (fields, methods, and constructors) of the superclass from within the subclass.

About the Author

This is a collection of insightful articles from domain experts in the fields of Cloud Computing, DevOps, AWS, Data Science, Machine Learning, AI, and Natural Language Processing. The range of topics caters to upski... Read Full Bio

Comments