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