When can you use super keyword?

In a scenario where you need to extend the functionality of a method from the parent class, the super keyword comes into play. For instance, consider a base class Animal with a method makeSound(). If you have a subclass Dog that overrides this method but still wants to include the base functionality, you can do it like this:

class Animal {
    void makeSound() {
        System.out.println("Some sound");
    }
}

class Dog extends Animal {
    void makeSound() {
        super.makeSound(); // Calls the parent class method
        System.out.println("Bark");
    }
}

In this example, the Dog class first calls makeSound() from Animal, and then adds its own implementation. This ensures that the behavior from the parent class is preserved while extending it. Such design helps in maintaining a clean and organized codebase, especially as the project grows.

Using the super keyword is also essential when dealing with constructors in inheritance. If a subclass has its own constructor, it can invoke the parent class constructor to ensure that the base class is properly initialized. For example:

class Vehicle {
    Vehicle(String type) {
        System.out.println("Vehicle type: " + type);
    }
}

class Car extends Vehicle {
    Car() {
        super("Car"); // Calls the parent class constructor
    }
}

Here, the Car constructor uses super to invoke the Vehicle constructor, passing in a string. This is crucial for initializing attributes defined in the parent class, promoting proper encapsulation and ensuring that the base class is set up correctly before the subclass adds its specific features.

In complex class hierarchies, the super keyword can help resolve method ambiguity. Consider a situation where a subclass overrides a method from two different parent classes. Using super allows you to specify which parent class's method to call. For example:

class A {
    void show() {
        System.out.println("Class A");
    }
}

class B {
    void show() {
        System.out.println("Class B");
    }
}

class C extends A, B {
    void show() {
        super.show(); // Calls the method from class A
    }
}

In this example, C can specify which show() method to invoke. This capability is particularly useful in languages that support multiple inheritance, ensuring clarity in method resolution and preventing potential conflicts.