super keyword in java

In Java, the super keyword is used to refer to the immediate parent class object. It is often used in the context of inheritance to access or call members (fields, methods, and constructors) of the parent class.

Here are the main uses of the super keyword:

  1. Accessing Fields or Methods of the Parent Class:
  • If a subclass has a field or method with the same name as a field or method in its superclass, the super keyword can be used to explicitly refer to the superclass version.
   class Parent {
       int value = 10;

       void display() {
           System.out.println("Parent class display");
       }
   }

   class Child extends Parent {
       int value = 20;

       void display() {
           System.out.println("Child class display");
           System.out.println("Child value: " + value); // Accessing child class variable
           System.out.println("Parent value: " + super.value); // Accessing parent class variable using super
           super.display(); // Calling parent class method
       }
   }

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

In this example, the Child class has a field value and a method display() that overrides the corresponding members in the Parent class. The super keyword is used to access the value field and call the display() method of the parent class.

  1. Calling the Parent Class Constructor:
  • The super keyword is used to invoke the constructor of the parent class. This is done in the constructor of the subclass and must be the first statement.
   class Parent {
       Parent() {
           System.out.println("Parent class constructor");
       }
   }

   class Child extends Parent {
       Child() {
           super(); // Calling parent class constructor
           System.out.println("Child class constructor");
       }
   }

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

In this example, the Child class constructor uses super() to call the constructor of the Parent class before executing its own constructor.

The super keyword plays a crucial role in maintaining the relationship between a subclass and its superclass. It allows for explicit differentiation between members of the subclass and those of the superclass, especially in cases of method or field overriding.

super has two general forms. The first calls the superclass’ constructor. The second is used to access a member 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);

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

class BoxWeight extends Box {
double weight; // weight of box
// initialize width, height, and depth using super()
BoxWeight(double w, double h, double d, double m) {
super(w, h, d); // call superclass constructor
weight = m;
}
}

Example

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;
}
}
// 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;
}
}
class DemoSuper {
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

When a subclass calls super( ), it is calling the constructor of its immediate superclass. Thus, super( ) always refers to the superclass immediately above the calling class. This is true even in a multileveled hierarchy. Also, super( ) must always be the first statement executed inside a subclass constructor

Leave a Comment