super Keyword in Java with Examples

In this article, we will discuss super keyword and it's usage with lots of examples.

The super keyword in Java is a reference variable that is used to refer parent class object.

The super has two general forms:

• The first calls the superclass constructor.
• The second is used to access methods or instance variables of the superclass that has been hidden by a member of a subclass.

Using super to Call Superclass Constructors

A subclass can call a constructor defined by its superclass by use of the following form of super:

super(arg-list);

Here, arg-list specifies any arguments needed by the constructor in the superclass. super( ) must always be the first statement executed inside a subclass’ constructor.

The below example demonstrates the usage of a super keyword to call the superclass constructor.

Step 1: Create a Box class with different versions of a constructor.

//A complete implementation of BoxWeight.
class Box {
    private double width;
    private double height;
    private double depth;

    //construct clone of an object
    Box(Box ob) { // pass object to constructor
        width = ob.width;
        height = ob.height;
        depth = ob.depth;
    }

    //constructor used when all dimensions specified
    Box(double w, double h, double d) {
        width = w;
        height = h;
        depth = d;
    }

    //constructor used when no dimensions specified
    Box() {
        width = -1; // use -1 to indicate
        height = -1; // an uninitialized
        depth = -1; // box
    }

    //constructor used when cube is created
    Box(double len) {
        width = height = depth = len;
    }

    //compute and return volume
    double volume() {
        return width * height * depth;
    }
}

Step 2: Create BoxWeight class that provides constructors for the various ways that a box can be constructed. In each case, super( ) is called using the appropriate arguments.

//BoxWeight now fully implements all constructors.
class BoxWeight extends Box {
    double weight; // weight of box
    //construct clone of an object

    BoxWeight(BoxWeight ob) { // pass object to constructor
        super(ob);
        weight = ob.weight;
    }

    //constructor when all parameters are specified
    BoxWeight(double w, double h, double d, double m) {
        super(w, h, d); // call superclass constructor
        weight = m;
    }

    //default constructor
    BoxWeight() {
        super();
        weight = -1;
    }

    //constructor used when cube is created
    BoxWeight(double len, double m) {
        super(len);
        weight = m;
    }
}

Here, BoxWeight( ) calls super( ) with the arguments w, h, and d. This causes the Box constructor to be called, which initializes width, height, and depth using these values.

BoxWeight no longer initializes these values itself. It only needs to initialize the value unique to it: weight. This leaves Box free to make these values private if desired.

Step 3: Let's create SuperKeyword class to test above use-cases:

package com.javaguides.corejava.keywords.superkeyword;

public class SuperKeyword {
    public static void main(String args[]) {
        BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);
        BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);
        BoxWeight mybox3 = new BoxWeight(); // default
        BoxWeight mycube = new BoxWeight(3, 2);
        BoxWeight myclone = new BoxWeight(mybox1);
        double vol;
        vol = mybox1.volume();
        System.out.println("Volume of mybox1 is " + vol);
        System.out.println("Weight of mybox1 is " + mybox1.weight);
        System.out.println();
        vol = mybox2.volume();
        System.out.println("Volume of mybox2 is " + vol);
        System.out.println("Weight of mybox2 is " + mybox2.weight);
        System.out.println();
        vol = mybox3.volume();
        System.out.println("Volume of mybox3 is " + vol);
        System.out.println("Weight of mybox3 is " + mybox3.weight);
        System.out.println();
        vol = myclone.volume();
        System.out.println("Volume of myclone is " + vol);
        System.out.println("Weight of myclone is " + myclone.weight);
        System.out.println();
        vol = mycube.volume();
        System.out.println("Volume of mycube is " + vol);
        System.out.println("Weight of mycube is " + mycube.weight);
        System.out.println();
    }
}

Output:

Volume of mybox1 is 3000.0
Weight of mybox1 is 34.3

Volume of mybox2 is 24.0
Weight of mybox2 is 0.076

Volume of mybox3 is -1.0
Weight of mybox3 is -1.0

Volume of myclone is 3000.0
Weight of myclone is 34.3

Volume of mycube is 27.0
Weight of mycube is 2.0

Using super keyword to call parent class methods and instance variables.

This usage has the following general form:

super.member

Here, a member can be either a method or an instance variable.

This second form of super is most applicable to situations in which member names of a subclass hide members by the same name in the superclass.

Let's demonstrates the usage of super keyword call parent class methods and instance variables with an example.

//Using super to overcome name hiding.
class A {
    int i;
}

class B extends A {
    int i; // this i hides the i in A

    B(int a, int b) {
        super.i = a; // i in A
        i = b; // i in B
    }

    void show() {
        System.out.println("i in superclass: " + super.i);
        System.out.println("i in subclass: " + i);
    }
}

class UseSuper {
    public static void main(String args[]) {
        B subOb = new B(1, 2);
        subOb.show();
    }
}

Output:

i in superclass: 1
i in subclass: 2

Summary

• super can be used to refer to immediate parent class instance variable.
• super can be used to invoke immediate parent class method.
• super() can be used to invoke immediate parent class constructor.

All Java Keywords 

1. abstract Java Keyword
2. assert Java Keyword
3. boolean Java Keyword
4. break Java Keyword
5. byte Java Keyword
6. case Java Keyword
7. catch Java Keyword
8. char Java Keyword
9. class Java Keyword
10. continue Java Keyword
11. default Java Keyword
12. do Java Keyword
13. double Java Keyword
14. else Java Keyword
15. enum Java Keyword
16. extends Java Keyword
17. final Java Keyword
18. finally Java Keyword
19. float Java Keyword
20. for Java Keyword
21. if Java Keyword
22. implements Java Keyword
23. import Java Keyword
24. instanceof Java Keyword
25. int Java Keyword
26. interface Java Keyword
27. long Java Keyword
28. native Java Keyword
29. new Java Keyword
30. package Java Keyword
31. private Java Keyword
32. protected Java Keyword
33. public Java Keyword
34. return Java Keyword
35. short Java Keyword
36. static Java Keyword
37. strictfp Java Keyword
38. super Java Keyword
39. switch Java Keyword
40. synchronized Java Keyword
41. this Java Keyword
42. throw Java Keyword
43. throws Java Keyword
44. transient Java Keyword
45. try Java Keyword
46. void Java Keyword
47. volatile Java Keyword
48. while Java Keyword