Go Beyond the Basics! Unleash the power of Java's 'super' keyword

Go Beyond the Basics! Unleash the power of Java's 'super' keyword. Understand how it connects you to your parent class for constructors, methods, and fields.

Welcome back to our Java exploration! Today, we're diving deep into a crucial aspect of inheritance in Java: the super keyword. This keyword allows you to access members of the parent class from within a subclass, enabling powerful code reuse and extension.

Understanding the 'super' Keyword

In Java, super is a reference variable that refers to the immediate parent class object. It's primarily used in two main scenarios:

• Calling the parent class constructor: You can use super() to invoke the constructor of the immediate parent class from within a subclass constructor. This is essential for initializing the inherited members. If you don't explicitly call super(), the Java compiler automatically inserts a call to the no-argument constructor of the parent class as the first statement in the subclass constructor.
• Accessing parent class methods and fields: When a subclass overrides a method or hides a field of the parent class, you can use super.methodName() or super.fieldName to access the original method or field from the parent class. This is useful when you want to extend the functionality of the parent class method rather than completely replacing it.

Calling the Parent Class Constructor: super()

Let's illustrate how to use super() to call the parent class constructor:

    
    class Animal {
        String name;

        public Animal(String name) {
            this.name = name;
            System.out.println("Animal constructor called with name: " + name);
        }

        public void makeSound() {
            System.out.println("Generic animal sound");
        }
    }

    class Dog extends Animal {
        String breed;

        public Dog(String name, String breed) {
            super(name); // Calling the Animal class constructor
            this.breed = breed;
            System.out.println("Dog constructor called with breed: " + breed);
        }

        @Override
        public void makeSound() {
            super.makeSound(); // Calling the makeSound method of the Animal class
            System.out.println("Woof!");
        }

        public void displayDetails() {
            System.out.println("Name: " + name + ", Breed: " + breed);
        }

        public static void main(String[] args) {
            Dog myDog = new Dog("Buddy", "Golden Retriever");
            myDog.makeSound();
            myDog.displayDetails();
        }
    }
    
   

In the Dog constructor, super(name) ensures that the Animal class's constructor is called first to initialize the name field.

Accessing Parent Class Methods: super.methodName()

The makeSound() method in the Dog class demonstrates how to call the parent class's method using super.makeSound() before adding its own specific behavior.

Accessing Parent Class Fields: super.fieldName

While less common due to the principles of encapsulation, you can also access public or protected fields of the parent class using super.fieldName if needed.

Important Notes about 'super':

• The call to super() must be the first statement in a subclass constructor.
• You can only use super() or this() in a constructor, not both.
• super cannot be used in a static context.

Conclusion

By following this guide, you’ve successfully grasped the power of Java's super keyword and its crucial role in inheritance. Understanding how to call parent class constructors and access parent class members allows you to build upon existing code, promote reusability, and create more organized and maintainable object-oriented applications. Keep experimenting with inheritance and the super keyword to solidify your understanding. Happy coding!

Show your love, follow us javaoneworld