In Java,the `super()` keyword is a crucial tool for working with inheritance. It allows a subclass to access members (methods and variables) of its superclass. This is particularly useful when you need to extend or modify the behavior of a parent class while still leveraging its existing functionality.

There are two primary uses of `super()`: calling the superclass constructor and accessing superclass members [2].

Calling the Superclass Constructor

When a subclass constructor is called, it implicitly calls the superclass’s constructor. If you don’t explicitly call a superclass constructor using `super()`, Java will automatically call the no-argument constructor of the superclass [3]. Though, if the superclass onyl has constructors that require arguments, you *must* explicitly call one of them using `super(arguments)` in the subclass constructor [2].

For example, consider a `Box` class and a `ColoredBox` subclass:

class box {
    int width, height, depth;

    Box(int w, int h, int d) {
        width = w;
        height = h;
        depth = d;
    }
}

class ColoredBox extends Box {
    String color;

    ColoredBox(int w, int h, int d, String c) {
        super(w, h, d); // Calls the Box constructor
        color = c;
    }
}
            

In this case, `super(w, h, d)` in the `ColoredBox` constructor calls the `Box` constructor, initializing the `width`, `height`, and `depth` variables. The `coloredbox` constructor then initializes its own `color` variable.

“The super keyword can be used to call the superclass constructor and to refer to a member of the superclass.” [2]

Accessing Superclass Members

The `super` keyword can also be used to access methods and variables of the superclass, even if they are overridden in the subclass.This is useful when you want to extend the functionality of a superclass method without fully replacing it.

For instance, if both the superclass and subclass have a method named `foo()`, you can call the superclass’s `foo()` method from the subclass using `super.foo()` [1].

Here’s an example:

class Parent {
    void foo() {
        System.out.println("Parent's foo()");
    }
}

class Child extends Parent {
    @Override
    void foo() {
        super.foo(); // Calls Parent's foo()
        System.out.println("Child's foo()");
    }
}
            

In this example, when `child.foo()` is called, it first executes the `Parent`’s `foo()` method and then executes its own code.