Super Keyword and Constructor Chaining in Java

In Java, the super keyword is used to refer to the immediate superclass of a class. It is typically used to access superclass methods and constructors. Constructor chaining refers to the process where a constructor calls another constructor in the same class or in the superclass, allowing for reusable code and initialization.

1. The super Keyword

The super keyword can be used in two main ways:

  • Accessing superclass methods
  • Accessing superclass constructors

Example 1: Using super to Access Superclass Methods

The super keyword is used to call a method from the superclass, especially when a method is overridden in the subclass. In the following example, we call the show() method from the superclass Animal using the super keyword.

    class Animal {
        void show() {
            System.out.println("This is an animal.");
        }
    }
    
    class Dog extends Animal {
        void show() {
            super.show(); // Calls the superclass method
            System.out.println("This is a dog.");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Dog dog = new Dog();
            dog.show();  // Calls the Dog class show() method, which calls the Animal class show() method
        }
    }

Output:

    This is an animal.
    This is a dog.

In this example, the subclass Dog calls the superclass Animal's show() method using super.show().

2. Using super to Access Superclass Constructors

In Java, the super keyword can also be used to call a constructor of the superclass. This is useful when the subclass wants to initialize the superclass before executing its own constructor.

Example 2: Using super() to Call a Superclass Constructor

In this example, the subclass Dog calls the constructor of the superclass Animal using super():

    class Animal {
        Animal() {
            System.out.println("Animal class constructor called.");
        }
    }
    
    class Dog extends Animal {
        Dog() {
            super(); // Calls the superclass constructor
            System.out.println("Dog class constructor called.");
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Dog dog = new Dog();  // Calls Dog class constructor, which calls Animal class constructor
        }
    }

Output:

    Animal class constructor called.
    Dog class constructor called.

In this example, the constructor of the superclass Animal is called before the constructor of the subclass Dog. The super() call ensures that the superclass is initialized first.

3. Constructor Chaining in Java

Constructor chaining is the process of calling one constructor from another. In Java, constructor chaining can be done in two ways:

  • Chaining within the same class using this()
  • Chaining between a superclass and subclass using super()

Example 3: Constructor Chaining within the Same Class Using this()

In this example, we use this() to call another constructor in the same class:

    class Dog {
        Dog() {
            System.out.println("Default constructor of Dog class.");
        }
    
        Dog(String name) {
            this();  // Calls the default constructor
            System.out.println("The dog's name is: " + name);
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Dog dog = new Dog("Buddy");  // Calls the Dog class constructor with a parameter
        }
    }

Output:

    Default constructor of Dog class.
    The dog's name is: Buddy

In this example, the parameterized constructor calls the default constructor using this(), resulting in constructor chaining within the same class.

Example 4: Constructor Chaining Between Superclass and Subclass Using super()

In this example, we chain constructors between a superclass and subclass:

    class Animal {
        Animal(String name) {
            System.out.println("Animal class constructor called with name: " + name);
        }
    }
    
    class Dog extends Animal {
        Dog(String name) {
            super(name);  // Calls the superclass constructor
            System.out.println("Dog class constructor called with name: " + name);
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Dog dog = new Dog("Buddy");  // Calls Dog class constructor, which calls Animal class constructor
        }
    }

Output:

    Animal class constructor called with name: Buddy
    Dog class constructor called with name: Buddy

In this case, the Dog class constructor calls the Animal class constructor using super(name), establishing constructor chaining between the subclass and superclass.

4. Constructor Chaining Rules

  • this() must be the first statement in the constructor.
  • super() must be the first statement in the constructor if you want to call a constructor of the superclass.
  • If no constructor is explicitly called, the default constructor of the superclass is called automatically.

5. Conclusion

The super keyword in Java is used for accessing methods and constructors from a superclass. It plays an important role in inheritance and constructor chaining. Constructor chaining allows you to call constructors within the same class or between a superclass and subclass, making it easier to reuse code and initialize objects efficiently. Understanding the super keyword and constructor chaining is essential for writing clean and maintainable Java code.




Advertisement