Super Keyword in Java

Last Updated: 06 March, 2023

In Java, the super keyword is a reference variable that is used to refer to the immediate parent class object. In inheritance, when the parent class and child class have members with the same name, then the super keyword solves the naming conflicts. The super keyword is used to refer to the parent class members.

In Java, when we create an instance of the child class, the JVM implicitly creates an instance of the parent class as well, which is referred to by the super reference variable.

The super keyword will only be used inside the child class, not in the parent class.

The super keyword is used for the following purposes in Java; let's see them below.

To refer the immediate parent class variables.
To refer the immediate parent class methods.
To call the immediate parent class constructor.

Example 1: To refer the immediate parent class variables

  class Parent {
    String str = "Parent";
  }
  
  class Child extends Parent {
  
    String str = "Child";
  
    void display() {
      System.out.println("Child class variable: " + str);
      // Using super keyword calling parent class variable
      System.out.println("Parent class variable: " + super.str);
    }
  }
  
  public class SuperExample1 {
    public static void main(String[] args) {
      Child obj = new Child();
      obj.display();
    }
  }

Output

Child class variable: Child
Parent class variable: Parent

Example 2: To refer the immediate parent class methods

  class ParentClass {
    
    void show() {
      System.out.println("Parent - show() method");
    }
  }
  
  class ChildClass extends ParentClass {
  
    void show() {
      System.out.println("Child - show() method");
    }
  
    void display() {
      System.out.println("Child - display() method");
      show(); // Calling same class show() method
      super.show(); // Calling Parent class show() method
    }
  }
  
  public class SuperExample2 {
    public static void main(String[] args) {
      ChildClass1 object = new ChildClass1();
      object.display();
      object.show(); // will call child class show() method
    }
  }

Output

Child - display() method
Child - show() method
Parent - show() method
Child - show() method

Example 3: To call the immediate parent class constructor

  class Parent {
    public Parent() {
      System.out.println("Parent class - Default constructor called");
    }
  
    public Parent(String name) {
      System.out.println("Parent class - Parameterized constructor value: " + name);
    }
  }
  
  class Child extends Parent1 {
    public Child() {
      // the default constructor of the Parent class is called by default.
      System.out.println("Child class - Default constructor\n");
    }
  
    public Child(String name) {
      super(); // super() method will call the default constructor of the Parent class.
      System.out.println("Child class - Parameterized constructor value: " + name + "\n");
    }
  
    public Child(int x, int y) {
      super("My Test Data"); // super() method will call Parent class String parameterized constructor.
      System.out.println("Child class - two Parameterized (int, int) constructor value: " + x + " " + y);
    }
  }
  
  public class SuperExample3 {
    public static void main(String arg[]) {
      // Calling Child class with default constructor
      Child1 child1 = new Child1();
  
      // Calling Child class with single parameterized constructor
      Child1 child2 = new Child1("Test");
  
      // Calling Child class with two parameterized constructor
      Child1 child3 = new Child1(10, 20);
    }
  }

Output

Parent class - Default constructor called
Child class - Default constructor

Parent class - Default constructor called
Child class - Parameterized constructor value: Test

Parent class - Parameterized constructor value: My Test Data
Child class - two Parameterized (int, int) constructor value: 10 20

Example 4: Call immediate parent class method in Multilevel Inheritance

  class A {
    void show() {
      System.out.println("A - show() method called");
    }
  }
  
  class B extends A {
    void show() {
      super.show();
      System.out.println("B - show() method called");
    }
  }
  
  class C extends B {
    void show() {
      super.show();
      System.out.println("C - show() method called");
    }
  }
  
  public class SuperExample4 {
    public static void main(String[] args) {
      C obj = new C();
      obj.show();
    }
  }

Output

A - show() method called
B - show() method called
C - show() method called

Super Keyword in Java

Currently No Video available