Scribd
Upload
62 views29 pages

Usage of Super Key Word Forms of Inheritance

The super keyword in Java has two main uses: 1. To call the constructor of the immediate parent class from within a subclass constructor using super(). This must be the first statement in the subclass constructor. 2. To access members of the parent class that have been hidden by members in the subclass using super.member. Inheritance in Java allows multilevel class hierarchies where subclasses can inherit features of all parent classes up the chain. The super() reference is always to the immediate parent class.

Uploaded by

Ganesh Nelluri
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
62 views29 pages

Usage of Super Key Word Forms of Inheritance

The super keyword in Java has two main uses: 1. To call the constructor of the immediate parent class from within a subclass constructor using super(). This must be the first statement in the subclass constructor. 2. To access members of the parent class that have been hidden by members in the subclass using super.member. Inheritance in Java allows multilevel class hierarchies where subclasses can inherit features of all parent classes up the chain. The super() reference is always to the immediate parent class.

Uploaded by

Ganesh Nelluri
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 29

Usage of super key word

forms of inheritance
Usage of super key word
• 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:
1. The first calls the superclass’
constructor.
2. The second is used to access a
member of the superclass that has
been hidden by a member of a
subclass.
• 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.
LTC: Usage of super key word
// 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
}
// 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;
}
class DemoSuper {
public static void main(String args[]) {
BoxWeight mybox1 = new BoxWeight(10, 20,
15, 34.3);
BoxWeight mybox3 = new BoxWeight(); //
default
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 = 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);
}
}
This program generates the following output:
Volume of mybox1 is 3000.0
Weight of mybox1 is 34.3
Volume of mybox3 is -1.0
Weight of mybox3 is -1.0
Volume of myclone is 3000.0
Weight of myclone is 34.3
• 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:
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.
Creating a Multilevel Hierarchy
• Up to this point, we have been using simple
class hierarchies that consist of only a
superclass and a subclass.
• However, you can build hierarchies that
contain as many layers of inheritance as you
like.
• It is perfectly acceptable to use a subclass as a
superclass of another.
• For example, given three classes called A, B,
and C, C can be a subclass of B, which is a
subclass of A.
• When this type of situation occurs, each
subclass inherits all of the traits found in all of
its superclasses.
• In this case, C inherits all aspects of B and A.
To see how a multilevel hierarchy can be useful,
consider the following program.

In it, the subclass BoxWeight is used as a


superclass to create the subclass called Shipment.

Shipment inherits all of the traits of BoxWeight


and Box, and adds a field called cost, which holds
the cost of shipping such a parcel.
 
// Extend BoxWeight to include shipping costs.
// Start with Box.
class Box {
private double width;
private double height;
private double depth;

// constructor used when all dimensions specified


Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
// Add weight.
class BoxWeight extends Box {
double weight; // weight of box

// constructor when all parameters are specified


BoxWeight(double w, double h, double d, double m) {
super(w, h, d); // call superclass constructor
weight = m;
}
}
// Add shipping costs.
class Shipment extends BoxWeight {
double cost;

// constructor when all parameters are specified


Shipment(double w, double h, double d,
double m, double c) {
super(w, h, d, m); // call superclass constructor
cost = c;
}
}
class DemoShipment {
public static void main(String args[]) {
Shipment sh =new Shipment(10, 20, 15, 10, 3.41);
double vol;
vol = sh.volume();
System.out.println("Volume of shipment is " + vol);
System.out.println("Weight of shipment is “+
sh.weight);
System.out.println("Shipping cost: $" + sh.cost);
}
}
The output of this program is shown here:
Volume of shipment1 is 3000.0
Weight of shipment1 is 10.0
Shipping cost: $3.41
• Because of inheritance, Shipment can make
use of the previously defined classes of Box
and BoxWeight, adding only the extra
information it needs for its own, specific
application.
• This is part of the value of inheritance; it
allows the reuse of code.
This example illustrates one other important
point:
super( ) always refers to the constructor
in the closest superclass.

The super( ) in Shipment calls the constructor in


BoxWeight.

The super( ) in BoxWeight calls the constructor in


Box.

End of session

You might also like

pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy