Home | | Web Programming | Using super - Java

Chapter: Java The Complete Reference : The Java Language : Inheritance

Using super - Java

In the preceding examples, classes derived from Box were not implemented as efficiently or as robustly as they could have been.

Using super


In the preceding examples, classes derived from Box were not implemented as efficiently or as robustly as they could have been. For example, the constructor for BoxWeight explicitly initializes the widthheight, and depth fields of Box. Not only does this duplicate code found in its superclass, which is inefficient, but it implies that a subclass must be granted access to these members. However, there will be times when you will want to create a superclass that keeps the details of its implementation to itself (that is, that keeps its data members private). In this case, there would be no way for a subclass to directly access or initialize these variables on its own. Since encapsulation is a primary attribute of OOP, it is not surprising that Java provides a solution to this problem. Whenever a subclass needs to refer to its immediate superclass, it can do so by use of the keyword super.

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. Each use is examined here.

Using super to Call Superclass Constructors


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




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.

To see how super( ) is used, consider this improved version of the BoxWeight class:


// BoxWeight now uses super to initialize its Box attributes. 

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;






Here, BoxWeight( ) calls super( ) with the arguments wh, and d. This causes the Box constructor to be called, which initializeswidthheight, 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.

In the preceding example, super( ) was called with three arguments. Since constructors can be overloaded, super( ) can be called using any form defined by the superclass. The constructor executed will be the one that matches the arguments. For example, here is a complete implementation of BoxWeight that provides constructors for the various ways that a box can be constructed. In each case,super( ) is called using the appropriate arguments. Notice that widthheight, and depth have been made private within Box.

// 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;






// 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); 



vol = mybox2.volume(); System.out.println("Volume of mybox2 is " + vol);


System.out.println("Weight of mybox2 is " + mybox2.weight); 



vol = mybox3.volume(); System.out.println("Volume of mybox3 is " + vol);


System.out.println("Weight of mybox3 is " + mybox3.weight); 



vol = myclone.volume(); System.out.println("Volume of myclone is " + vol);


System.out.println("Weight of myclone is " + myclone.weight); 



vol = mycube.volume(); System.out.println("Volume of mycube is " + vol);


System.out.println("Weight of mycube is " + mycube.weight); 





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


Pay special attention to this constructor in BoxWeight:


// construct clone of an object


BoxWeight(BoxWeight ob) { // pass object to constructor super(ob);


weight = ob.weight;




Notice that super( ) is passed an object of type BoxWeight—not of type Box. This still invokes the constructor Box(Box ob). As mentioned earlier, a superclass variable can be used to reference any object derived from that class. Thus, we are able to pass aBoxWeight object to the Box constructor. Of course, Box only has knowledge of its own members.

Let’s review the key concepts behind super( ). 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.


A Second Use for 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:




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:



     Using super to overcome name hiding. 

class A {


int i;




Create a subclass by extending 

class A.

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);








This program displays the following:


i in superclass: 1 i in subclass: 2


Although the instance variable i in B hides the i in Asuper allows access to the i defined in the superclass. As you will see, supercan also be used to call methods that are hidden by a subclass.

Study Material, Lecturing Notes, Assignment, Reference, Wiki description explanation, brief detail
Java The Complete Reference : The Java Language : Inheritance : Using super - Java |

Privacy Policy, Terms and Conditions, DMCA Policy and Compliant

Copyright © 2018-2023 BrainKart.com; All Rights Reserved. Developed by Therithal info, Chennai.