How to Call Parent Methods In Java/Groovy?

In Java and Groovy, you can call parent class methods using the super keyword followed by a dot and the method name. This allows you to access and execute the parent class methods from the child class. By using the super keyword, you can invoke the parent class constructor or methods within the child class. This is useful when you want to extend the functionality of a parent class in the child class while still being able to access and utilize the parent class methods. Make sure to use this feature carefully to maintain proper inheritance relationships and avoid conflicts in method overriding.

What is the outcome of calling a non-existent parent method in Java?

If a non-existent parent method is called in Java, it will result in a compilation error. The compiler will not be able to find the method in the parent class and will throw an error during compilation.

How to call a parameterized parent method in Java?

To call a parameterized parent method in Java, you can use the super keyword along with the method name and pass the required parameters. Here is an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class Parent {
    void showMessage(String message) {
        System.out.println("Parent: " + message);
    }
}

class Child extends Parent {
    @Override
    void showMessage(String message) {
        super.showMessage(message); // calling parent method with parameter
        System.out.println("Child: " + message);
    }
}

public class Main {
    public static void main(String[] args) {
        Child child = new Child();
        child.showMessage("Hello");
    }
}

In the above example, the Child class has overridden the showMessage method of the Parent class. Inside the showMessage method of the Child class, super.showMessage(message) is used to call the showMessage method of the Parent class with the specified message parameter.

How to call superclass methods in Java?

To call superclass methods in Java, you can use the super keyword followed by a dot and the method name.

For example, if you have a subclass that overrides a method from its superclass, you can still call the superclass method by using super.methodName().

Here is an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

class Superclass {
    public void display() {
        System.out.println("This is superclass method");
    }
}

class Subclass extends Superclass {
    @Override
    public void display() {
        super.display(); // Calling superclass method
        System.out.println("This is subclass method");
    }
}

public class Main {
    public static void main(String[] args) {
        Subclass obj = new Subclass();
        obj.display();
    }
}

In this example, the Superclass has a display() method that is overridden in the Subclass. Using super.display() in the Subclass allows you to call the superclass method before executing the subclass method.