1
0

Use of Super

A subclass constructor is used to initialize the instance variables of both the subclass and the superclass. The subclass constructor uses the keyword super to invoke the constructor method of the superclass. The use of the keyword super is subjected to the following conditions:

  1. super may only be used within a subclass constructor method.
  2. The call to the superclass constructor must appear as the first statement within the subclass constructor
  3. The parameters in the super call must match the order and the type of parameters used in the superclass constructor.

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

super(parameter-list);

Here, parameter-list specifies any parameters needed by the constructor in the superclass. super() must always be the first statement executed inside a subclass’ constructor. The following program illustrates the use of super() method for passing parameters to a superclass.

Program to implement the working of the superclass constructor

class Box
{
    private double width;
    private double height;
    private double depth;
    // construct clone of an object also refered to as copy constructor
    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 default constructor
    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 contructor
    {
        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;
    }
    // defalut constructor
    BoxWeight()
    {
        super();        // call superclass constructor
        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();
    }
}

This program generates the following 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

Concentrate on the use of super keyword. super(ob); call the Box(Box ob) constructor and pass the BoxWeight object reference to Box object. In another constructor super(w, h, d); call the Box(double w, double h, double d) constructor of the Box class and pass the corresponding parameters. In this way, private members of the base class can be initialized by the constructor of drived class.

The second use of ‘super’

The second form of super acts somewhat like this, except that it always refers to the superclass of the subclass in which it is used. This usage has the following general form:

    super.member

Here, 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. Consider this simple class hierarchy:

Program to implement the working of the ‘super’ keyword in another form.

class A
{
    int var;
    void show()
    {
        System.out.println("Value of var in class A: " + var);
    }
}
// Create a subclass by extending class A.
class B extends A
{
    int var;        // this 'var' hides the 'var' in A
    B(int p, int q)
    {
        super.var = p;  // var in A
        var = q;    // var in B
    }
    void show()
    {
        super.show();   // show() method of class A
        System.out.println("Variable in superclass: " + super.var);
        System.out.println("Variable in subclass: " + var);
    }
}
class SecondSuper
{
    public static void main(String s[])
    {
        B sub1 = new B(12, 34);
        sub1.show();
    }
}

This program displays the following:

Value of var in class A: 12
Variable in superclass: 12
Variable in subclass: 34

Although the instance variable var in B hides the var in A and method show() hides the show() method of class A, super allows access to the var and show() defined in the superclass. So you can use, super to call methods and access members that are hidden by a subclass.

Calling subclass methods with superclass object

A reference variable of a superclass can be assigned a reference to any subclass object. You will find this aspect of inheritance quite useful in a variety of situations. But care must be taken about the following constraints:

  1. A superclass object can store the subclass object reference.
  2. Superclass objects can only refer to those members who are declared in the superclass itself.

For example, consider the following:

Program for Calling subclass methods with superclass object

class SuperDemo
{
    public static void main(String s[])
    {
        BoxWeight wtbox = new BoxWeight(3, 5, 7, 8.37);
        Box plbox = new Box();
        double vol;
        vol = wtbox.volume();
        System.out.println("Volume of weightbox is " + vol);
        System.out.println("Weight of weightbox is " + wtbox.we);
        System.out.println();
        plbox = wtbox;      // assign BoxWeight reference to Box reference
        vol = plbox.volume();   // OK, volume() defined in Box
        System.out.println("Volume of plainbox is " + vol);
        // The following statement is invalid because
        // Box class does not define a weight member
        // System.out.println("Weight of plainbox is " + plbox.weight);
    }
}

Here, wtbox is a reference to BoxWeight objects, and plbox is a reference to Box objects. Since BoxWeight is a subclass of Box, it is permissible to assign plbox a reference to the wtbox object.

It is important to understand that it is the type of the reference variable – not the type of object that it refers to – that determines what members can be accessed. That is, when a reference to a subclass object is assigned to a superclass reference variable, you will have access only to those parts of the object defined by the superclass. This is why plbox can’t access weight even when it refers to a BoxWeight object. If you think about it, this makes sense, because the superclass has no knowledge of what a subclass adds to it. This is why the last line of code in the preceding fragment is commented out. It is not possible for a Box reference to access the weight field, because it does not define one. Although the preceding may seem a bit esoteric, it has some important practical applications – two of which are discussed later in further topics. 

Leave a Reply