Object Oriented Paradigm
Lecture # 8
Outline
Inheritance
A Superclass Variable can Reference a Subclass
Object
Using super
2
Inheritance
We can create a general class that defines traits
common to a set of related items
This class can then be inherited by others, more
specific classes, each adding those things that are
unique to it
A class that is inherited is called a superclass.
The class that does the inheriting is called a subclass.
Therefore, a subclass is a specialized version of a
superclass.
3
Inheritance
To inherit a class, we simply incorporate the definition of
one class into another by using the extends keyword.
The general form of a subclass declaration is:
class subclass-name extends superclass-name
{ /*body of class*/ }
We can specify only one superclass for any subclass.
This is because Java does not support multiple
inheritance.
4
Inheritance
// A simple example of inheritance.
// Create a superclass.
class A {
int i, j;
void showij() {
System.out.println("i and j: " + i + " " + j);
}
}
Program continues on next slide … 5
Inheritance
// Create a subclass by extending class A.
class B extends A {
int k;
void showk() {
System.out.println("k: " + k);
}
void sum() {
System.out.println("i+j+k: " + (i+j+k));
}
}
Program continues on next slide … 6
class SimpleInheritance {
public static void main(String args[]) {
A superOb = new A();
B subOb = new B();
superOb.i = 10;
superOb.j = 20;
System.out.println("Contents of superOb: ");
superOb.showij();
System.out.println();
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij(); Contents of superOb:
subOb.showk(); i and j: 10 20
System.out.println(); Contents of subOb:
System.out.println("Sum of i, j and k in subOb:"); i and j: 7 8
subOb.sum(); k: 9
} Sum of i, j and k in subOb:
7
} i+j+k: 24
Member Access and Inheritance
Although a subclass includes all of the members
of its superclass, it cannot access those
members of the superclass that have been
declared as private.
8
A More Practical Example
// This program uses inheritance to extend Box.
class Box {
double width;
double height;
double depth;
// construct clone of an object
Box(Box ob) { // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}
Program continues on next slide … 9
A More Practical Example
// 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
}
Program continues on next slide … 10
A More Practical Example
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
Program continues on next slide … 11
A More Practical Example
// Here, Box is extened to include weight.
class BoxWeight extends Box {
double weight; // weight of box
// constructor for BoxWeight
BoxWeight(double w, double h, double d, double m) {
width = w;
height = h;
depth = d;
weight = m;
}
}
Program continues on next slide … 12
class DemoBoxWeight {
public static void main(String args[]) {
BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);
BoxWeight mybox2 = new BoxWeight(2, 3, 4, 0.076);
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);
} Volume of mybox1 is 3000.0
Weight of mybox1 is 34.3
}
Volume of mybox2 is 24.0
13
Weight of mybox2 is 0.076
A Superclass Variable can Reference a
Subclass Object
A reference variable of a superclass can be
assigned a reference to any subclass
derived from that superclass.
SuperClass referenceVariable=new SubClass();
Or
SubClass subClassReference=new SubClass();
SuperClass referenceVariable=subClassReference;
14
A Superclass Variable can Reference a
Subclass Object
class RefDemo {
public static void main(String args[]) {
BoxWeight weightbox = new BoxWeight(3, 5, 7, 8.37);
Box plainbox = new Box();
double vol;
vol = weightbox.volume();
System.out.println("Volume of weightbox is " + vol);
System.out.println("Weight of weightbox is " + weightbox.weight);
System.out.println();
plainbox = weightbox;
vol = plainbox.volume(); // OK, volume() defined in Box
System.out.println("Volume of plainbox is " + vol);
// System.out.println("Weight of plainbox is " + plainbox.weight);
}
15
}
A Superclass Variable can Reference a
Subclass Object
It is important to understand that it is the type of the
reference variable – not the type of the object that it
refers to – that determines what members can be
accessed.
When a reference to a subclass object is assigned to a
superclass reference variable, we will have access only
to those parts of the object defined by the
superclass.
16
Using super
BoxWeight(double w, double h, double d, double m) {
width = w; height = h;
depth = d; weight = m;
}
The subclass constructor explicitly initializes instance
variables of superclass.
– This duplicates the code found in superclass.
– It implies that a subclass must be granted access to these
members.
What if the superclass data is kept private?
super gives the solution. Whenever a subclass needs to
refer to its immediate superclass, it can do so by use of
the keyword super.
17
Using super
super has two general forms:
– The 1st calls the superclass constructor.
– The 2nd is used to access a member of the superclass
that has been hidden by a member of a subclass
18
Using super to Invoke Superclass
Constructor
A subclass can call a constructor method defined
by its superclass by use of the following form of
super:
super(parameter-list);
super() must always be the first statement
executed inside a subclass’ constructor.
19
Using super to Invoke Superclass
Constructor
// 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;
}
}
20
Using super to Invoke Superclass
Constructor
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.
21
Using super to Invoke Superclass
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;
}
Program continues on next slide … 22
Using super to Invoke Superclass
Constructor
// 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
}
Program continues on next slide … 23
Using super to Invoke Superclass
Constructor
// constructor used when cube is created
Box(double len) {
width = height = depth = len;
}
// compute and return volume
double volume() {
return width * height * depth;
}
}
Program continues on next slide … 24
Using super to Invoke Superclass
Constructor
// 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
When invoking
super(ob); Box(Box ob),
weight = ob.weight; super() is called
with an object of
} type BoxWeight
// constructor when all parameters are specified – not of type Box.
This is because a
BoxWeight(double w, double h, double d, double m) { superclass variable
super(w, h, d); // call superclass constructor can be used to
reference any
weight = m; object derived
} from that class.
Program continues on next slide … 25
Using super to Invoke Superclass
Constructor
// default constructor
BoxWeight() {
super();
weight = -1;
}
// constructor used when cube is created
BoxWeight(double len, double m) {
super(len);
weight = m;
}
}
Program continues on next slide … 26
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 = 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);
}
27
}
Using super to Access Hidden
Members of Superclass
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.
It has the following general form
super.member
This form of super is most applicable to
situations in which member names of a subclass
hide members by the same name in the
superclass.
28
Using super to Access Hidden
Members of Superclass
// 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
} 29
Using super to Access Hidden
Members of Superclass
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();
} i in superclass: 1
i in subclass: 2
} 30
Recommended Reading
Pages 159-169, Chapter # 8: Inheritance from
Herbert Schildt, Java: The Complete Reference,
J2SETM 5 Edition
31
