Inheritance and Polymorphism

1
 Motivations
Suppose you will define classes to model
circles, rectangles, and triangles. These
classes have many common features.
What is the best way to design these
classes so to avoid redundancy? The
answer is to use inheritance.

2
 Objectives
⚫ Relationships between classes
⚫ Inheritance Relationship
⚫ To define a subclass from a superclass.
⚫ To invoke the superclass’s constructors and methods using the
super keyword.
⚫ To override instance methods in the subclass.
⚫ To distinguish differences between overriding and overloading.
⚫ To explore the toString() method in the Object class.
⚫ To explore the equals() method in the Object class.
⚫ To discover polymorphism and dynamic binding.
⚫ To describe casting and explain why explicit down casting is
necessary.

3
 Inheritance Relationship between
classes
There are different types of relationships
between classes: (has-a relationship
Composition
Aggregation
Inheritance (is-a relationship

In this lecture we will concentrate on the

inheritance relationship (is-a relationship) and
how to implement it in Java O.O. language.
 Aggregation Relationships
⚫ Aggregations models has-a relationships and
form a Whole-Part relationship between two
classes.
⚫ If you delete the Whole class (aggregating), the
Part one (Aggregated) will remain.

Aggregated
Aggregating
Class
Class

5
 Composition Relationships
⚫Composition is a stronger form of aggregation .
⚫If the aggregating (composing) object is deleted,
all of the aggregated (composed) objects must be
deleted.

Consider a Window object

containing a ScrollBar and a
Button. If the window is
destroyed, the scroll bar and
button must

6
 Class Representation
An aggregation relationship is usually
represented as a data field in the aggregating
class. follows:
public class Name { public class Student { public class Address {
... private Name name; ...
} private Address address; }

...
}

Aggregated class Aggregating class Aggregated class

Composition Aggregation

1 1 1..3 1
Name Student Address 7
 Aggregation or Composition

Since aggregation and composition

relationships are represented using
classes in similar ways, many texts don’t
differentiate them and call both
compositions.

8
 Inheritance

⚫Inheritance is an Object oriented feature

which allows a class to inherit behavior
(methods) and data from other class.

⚫With the use of inheritance the information

is made manageable in a hierarchical
order.
 Subclass and SuperClass
⚫ The class which inherits the properties of other
is known as subclass (derived class, child class).
The subclass can have additional methods and
data in addition to inherited ones.

⚫ The class whose properties are inherited is

known as superClass (base class, parent class).
Superclass holds the common data and
methods.
 UML Notation for inheritance
What are the members of each class in the below class diagram?

SuperClass

Subclass

Subclass

Inheritance
UML
notation
 The Class Heirarchy
⚫ There are two types in Java hierarchy:
1. user-defined
2. Java class library.

⚫ The figure below shows a user-defined hierarchy.

⚫ class C and class D inheriting from class B which, in turn, inherits
from class A.
 Java inheritance hierarchy
The figure below shows part of the Java inheritance hierarchy,
including the root of the hierarchy, which is the class whose name is
Object.
The class Object has no superclass.
 Why Inheritance?

⚫The main benefit behind the inheritance is

the reusability feature, where a new class
(subclass) can be created using an
existing one which save effort, time, avoid
redundancy and reduce time of testing.
 Syntax of Java Inheritance

⚫The extends keyword is used to represent

inheritance relationship in Java language.

⚫ The general format of subclass is:

public class Subclass-name extends Superclass-name

{
//methods and fields
}
Superclasses and Subclasses
SimpleGeometricObject
-color: String The color of the object (default: white).
-filled: boolean Indicates whether the object is filled with a color (default: false).
-dateCreated: [Link] The date when the object was created.
+GeometricObject() Creates a GeometricObject.
+GeometricObject(color: String, Creates a GeometricObject with the specified color and filled
filled: boolean) values.
+getColor(): String Returns the color.
+setColor(color: String): void Sets a new color.
SimpleGeometricObject
+isFilled(): boolean Returns the filled property.
+setFilled(filled: boolean): void Sets a new filled property. Circle
+getDateCreated(): [Link] Returns the dateCreated.
+toString(): String Returns a string representation of this object.

Rectangle
Circle Rectangle
-radius: double -width: double
+Circle() -height: double TestCircleR
+Circle(radius: double) +Rectangle() ectangle
+Circle(radius: double, color: String, +Rectangle(width: double, height: double)
filled: boolean) +Rectangle(width: double, height: double
+getRadius(): double color: String, filled: boolean)
+getWidth(): double
Run
+setRadius(radius: double): void
+getArea(): double +setWidth(width: double): void
+getPerimeter(): double +getHeight(): double
+getDiameter(): double +setHeight(height: double): void
+printCircle(): void +getArea(): double
+getPerimeter(): double

16
 Example: SimpleGeometricObject Class

import [Link];
public class SimpleGeometricObject { public boolean isFilled()
private String color = "white"; { return filled; }
private boolean filled;
private Date dateCreated; public void setFilled(boolean filled)
{ [Link] = filled;}
public SimpleGeometricObject() {
dateCreated = new [Link](); public Date getDateCreated()
} {
public SimpleGeometricObject(String color, return dateCreated;
boolean filled) { }
dateCreated = new Date();
[Link] = color; public String toString() {
[Link] = filled; return "created on " +
} dateCreated +
public String getColor() { return color; } "\ncolor: " + color +
" and filled: " +
public void setColor(String color) filled;
{[Link] = color;} }

}
 Continue: Circle class
public class Circle extends
SimpleGeometricObject { public double getArea()
private double radius; { return radius * radius *

public Circle() { } [Link]; }

public Circle(double radius) public double getDiameter()

{ [Link] = radius; } { return 2 * radius; }

public Circle(double radius, String public double getPerimeter()

color, boolean filled) { return 2 * radius * [Link]; }
{ [Link] = radius; public void printCircle() {
setColor(color);
[Link]("The circle
setFilled(filled); }
is created " + getDateCreated()
public double getRadius() + " and the radius is " +
{ return radius; } radius);
public void setRadius(double radius) }
{ [Link] = radius; } }
 Continue: Class Rectangle
public class Rectangle extends
SimpleGeometricObject { public void setWidth(double width)

private double width, height; { [Link] = width; }

public double getHeight()
public Rectangle() { }
{ return height; }
public Rectangle( double w, double h)
public void setHeight(double height)
{ [Link] = w; [Link] = h; }
{ [Link] = height; }
public Rectangle( double w, double h,
String color, boolean filled) public double getArea()
{ [Link] = w; [Link] = h; { return width * height; }
setColor(color); setFilled(filled);
public double getPerimeter()
}
{ return 2 * (width + height); }
public double getWidth()
}
{ return width; }
 Continue: Class Test
public class TestCircleRectangle {
public static void main(String[] args) {
Circle circle = new Circle(1);
[Link]("A circle " + [Link]());
[Link]("The color is " + [Link]());
[Link]("The radius is " + [Link]());
[Link]("The area is " + [Link]());
[Link]("The diameter is " + [Link]());

Rectangle rectangle = new 2, 4);

[Link]("\n A rectangle " + [Link]());
[Link]("The area is " + [Link]());
[Link]("The perimeter is " + [Link]());
}
}
 Are superclass’s Constructor
Inherited?
❑No. They are not inherited.
❑ A constructor is used to construct an instance of a class.
Unlike properties and methods, a superclass's constructors
are not inherited in the subclass.
❑ They can only be invoked from the subclasses' constructors
explicitly, using the keyword super().
❑ If the keyword super() is not explicitly used, the
superclass's no-arg constructor is automatically
(implicitly) invoked.

21
 Superclass’s Constructor Is Always
Invoked
A constructor may invoke an overloaded constructor or
its superclass’s constructor. If none of them is invoked
explicitly, the compiler puts super() as the first
statement in the constructor. For example,
public A() { public A() {
is equivalent to
} super();
}

public A(double d) { public A(double d) {

// some statements is equivalent to
super();
} // some statements
}

22
 Using the Keyword super

The keyword super refers to the superclass of

the class in which super appears. This keyword
can be used in two ways:
❑To call a superclass constructor fromsub-
class constructor: super() as a first statement
in sub class constructor
❑To call a superclass method from a sub-class
method: [Link]()
23
 Defining a Subclass
A subclass inherits from a superclass. A
subclass can also:
❑ Have new properties
❑ Have new methods
❑ Override the methods of the superclass

24
 Calling Superclass Methods
You could rewrite the printCircle() method in the
Circle class as follows:

public void printCircle() {

[Link]("The circle is
created " + [Link]() +
" and the radius is " + radius);
}

25
 Overriding Methods in the
Superclass
A subclass inherits methods from a superclass. Sometimes it
is necessary for the subclass to modify the implementation of
a method defined in the superclass. This is referred to as
method overriding.
public class Circle extends GeometricObject {
// Other methods are omitted

/** Override the toString() method defined in GeometricObject */

public String toString() {

return [Link]() + "\nradius is " + radius;
}
}

26
 NOTE
❑An instance method can be overridden
only if it is accessible.
❑Thus a private method cannot be
overridden, because it is not accessible
outside its own class.
❑If a method defined in a subclass is
private in its superclass, the two methods
are completely unrelated.
27
 NOTE

❑Like an instance method, a static

method can be inherited. However, a
static method cannot be overridden.
❑If a static method defined in the
superclass is redefined in a subclass, the
method defined in the superclass is
hidden.

28
 Overloading VS. Overriding
⚫ Overloading: is the process of having more
than one method in the same class, or inherited
from some superclass, with the same name but
a different method signature, i.e. different types
and/or numbers or arguments.
⚫ Overriding: is the process of having more than
one methods with same name and same
signature in super and sub class but with
different implementation. Wherein a subclass
redefines or replaces the inherited method.
 Overriding vs. Overloading
public class Test { public class Test {
public static void main(String[] args) { public static void main(String[] args) {
A a = new A(); A a = new A();
a.p(10); a.p(10);
a.p(10.0); a.p(10.0);
} }
} }

class B { class B {
public void p(double i) { public void p(double i) {
[Link](i * 2); [Link](i * 2);
} }
} }

class A extends B { class A extends B {

// This method overrides the method in B // This method overloads the method in B
public void p(double i) { public void p(int i) {
[Link](i); [Link](i);
} }
} }

30
 Overriding
public class Parent{ public class Test{
public void method(int i) public static void main()
{ [Link](“parent:”+i);} { Parent k = new child();
} Parent P = new Parent();
public class child extends Parent { Child c = new child();
public void method(int i) [Link](1);
{ [Link](“child:”+i*2);} [Link](2);
} [Link](3);
}
}

The output is:

child 2
Parent 2
child 6
 The protected Modifier
❑The protected modifier can be applied on
data and methods in a class. A protected data
or a protected method in a public class can be
accessed by any class in the same package
or its subclasses, even if the subclasses are
in a different package.
❑private, default, protected, public
Visibility increases

private, none (if no modifier is used), protected, public

32
 Accessibility Summary

Modifier Accessed Accessed Accessed Accessed

on members from the from the from a from a different
in a class same class same package subclass package

public

protected -

default - -

private - - -

33
 Visibility Modifiers
package p1;
public class C1 { public class C2 {
public int x; C1 o = new C1();
protected int y; can access o.x;
int z; can access o.y;
private int u; can access o.z;
cannot access o.u;
protected void m() {
} can invoke o.m();
} }

package p2;

public class C3 public class C4 public class C5 {

extends C1 { extends C1 { C1 o = new C1();
can access x; can access x; can access o.x;
can access y; can access y; cannot access o.y;
can access z; cannot access z; cannot access o.z;
cannot access u; cannot access u; cannot access o.u;
can invoke m(); can invoke m(); cannot invoke o.m();
} } }

34
 A Subclass Cannot Weaken the
Accessibility
❑A subclass may override a protected
method in its superclass and change its
visibility to public.
❑However, a subclass cannot weaken the
accessibility of a method defined in the
superclass. For example, if a method is
defined as public in the superclass, it must
be defined as public in the subclass.
35
 The final Modifier
❑ The final class cannot be extended
(inherited):
final class Math {
...
}

❑ The final variable is a constant:

final static double PI = 3.14159;

❑ The final method cannot be

overridden by its subclasses.

36
 The Object Class and Its Methods
Every class in Java is descended from the
[Link] class. If no inheritance is
specified when a class is defined, the
superclass of the class is Object.

public class Circle { public class Circle extends Object {

... Equivalent
...
} }

37
 The toString() method in Object
The toString() method returns a string representation of
the object. The default implementation returns a string
consisting of a class name of which the object is an
instance, the at sign (@), and a number representing
this object.
Loan loan = new Loan();
[Link]([Link]());

The code displays something like Loan@15037e5 . This

message is not very helpful or informative. Usually you should
override the toString method so that it returns a digestible string
representation of the object.
38
 The equals Method
The equals() method compares the
contents of two objects. The default implementation of
the equals method in the Object class is as follows:
public boolean equals(Object obj) {
return this == obj;
}

public boolean equals(Object o) {

For example, the if (o instanceof Circle) {
equals method is return radius == ((Circle)o).radius;
overridden in }
the Circle else
return false;
class. }

39
 NOTE
❑The == comparison operator is used for comparing
two primitive data type values or for determining
whether two objects have the same references.
❑The equals method is intended to test whether two
objects have the same contents, provided that the
method is modified in the defining class of the
objects.
❑The == operator is stronger than the equals
method, in that the == operator checks whether the
two reference variables refer to the same object.
40
 The instanceof Operator

Use the instanceof operator to test whether an

object is an instance of a class:

Object myObject = new Circle();

... // Some lines of code
/** Perform casting if myObject is an instance
of Circle */
if (myObject instanceof Circle) {
[Link]("The circle diameter is "
+
((Circle)myObject).getDiameter());
...
}

41
 Exercise

Use the GemotricObject class and its subclassess

Cirlce and Rectangle to do the following:
1. Override Object’s toString() method in Circle class to
returnthe status of Circle object.
2. Override Object’s toString() method in Rectangle class
to return the status of Rectangle object.
3. Overide Object’s equals() method to compare two circle
objects.
4. Overide Object’s equals() method to compare two
Rectangle objects.
5. Test the above statements in the main method.
 Polymorphism

Polymorphism: the ability for a word or symbol to

mean different things in different contexts.
Types of Polymorphism:
⚫ The most common use of polymorphism in OOP occurs
when a parent class reference is used to refer to a child
class object.
⚫ Having Methods with the same name in different classes
with relationship or without. These methods may differ in
arguments, implementation or no change at all.
Overriding and overloading are types of polymorphism.
 Polymorphism in Java
Polymorphism means that a variable of a
supertype can refer to a subtype object.
❑A class defines a type. A type defined by a
subclass is called a subtype, and a type defined
by its superclass is called a supertype.
❑Therefore,you can say that Circle is a
subtype of GeometricObject and
GeometricObject is a supertype for Circle.
PolymorphismDemo Run
44
 Polymorphism, Dynamic Binding and Generic Programming
public class PolymorphismDemo {
public static void main(String[] args) { Method m takes a parameter
m(new GraduateStudent());
m(new Student()); of the Object type. You can
m(new Person());
m(new Object()); invoke it with any object.
}
An object of a subtype can be used wherever
public static void m(Object x) {
[Link]([Link]()); its supertype value is required. This feature is
}
} known as polymorphism.
class GraduateStudent extends Student {
}
When the method m(Object x) is executed, the
argument x’s toString method is invoked. x may be
class Student extends Person {
public String toString() {
an instance of GraduateStudent, Student, Person, or
return "Student"; Object. Classes GraduateStudent, Student, Person,
} and Object have their own implementation of the
}
toString method. Which implementation is used will
class Person extends Object { be determined dynamically by the Java Virtual
public String toString() {
return "Person"; Machine at runtime. This capability is known as
} dynamic binding.
} Output:
Student
Student
DynamicBindingDemo Run
Person
[Link]@b8bef745
 Dynamic Binding
❑Dynamic binding works as follows: Suppose an object o is
an instance of classes C1, C2, ..., Cn-1, and Cn, where C1 is a
subclass of C2, C2 is a subclass of C3, ..., and Cn-1 is a
subclass of Cn. That is, Cn is the most general class, and C1
is the most specific class.
❑In Java, Cn is the Object class. If o invokes a method p,
the JVM searches the implementation for the method p in
C1, C2, ..., Cn-1 and Cn, in this order, until it is found. Once
an implementation is found, the search stops and the first-
found implementation is invoked.

Cn Cn-1 ..... C2 C1

Since o is an instance of C1, o is also an

Object instance of C2, C3, …,
46
Cn-1, and Cn
 Method Matching vs. Binding
Matching a method signature and binding a
method implementation are two issues.
❑The compiler finds a matching method
according to parameter type, number of
parameters, and order of the parameters at
compilation time.
❑A method may be implemented in several
subclasses. The Java Virtual Machine dynamically
binds the implementation of the method at
runtime.

47
 Generic Programming
public class PolymorphismDemo {
public static void main(String[] args) {
m(new GraduateStudent()); ▪Polymorphism allows methods to be
m(new Student());
m(new Person()); used generically for a wide range of
m(new Object());
}
object arguments. This is known as
generic programming.
public static void m(Object x) {
[Link]([Link]()); ▪If a method’s parameter type is a
}
} superclass (e.g., Object), you may
class GraduateStudent extends Student {
pass an object to this method of any of
} the parameter’s subclasses (e.g.,
class Student extends Person { Student or String).
public String toString() {
return "Student"; ▪When an object (e.g., a Student
}
} object or a String object) is used in the
class Person extends Object {
method, the particular implementation
public String toString() { of the method of the object that is
return "Person";
} invoked (e.g., toString) is determined
} dynamically.

48
 Casting Objects
You have already used the casting operator to convert
variables of one primitive type to another. Casting can
also be used to convert an object of one class type to
another within an inheritance hierarchy.
In the preceding section, the statement
m(new Student());

assigns the object new Student() to a parameter of the

Object type. This statement is equivalent to:

Object o = new Student(); // Implicit casting

m(o);
The statement Object o = new Student(), known as
implicit casting, is legal because an instance of
Student is automatically an instance of Object.
49
 Why Casting Is Necessary?
Suppose you want to assign the object reference o to a variable of
the Student type using the following statement:

Student b = o; //A compiler error would occur

Why does the statement Object o = new Student() work and the
statement Student b = o doesn’t?
This is because a Student object is always an instance of Object, but
an Object is not necessarily an instance of Student.
Even though you can see that o is really a Student object, the
compiler is not so clever to know it.
To tell the compiler that o is a Student object, use an explicit casting.
The syntax is similar to the one used for casting among primitive
data types. Enclose the target object type in parentheses and place
it before the object to be cast, as follows:
Student b = (Student)o; // Explicit casting
50
 Casting from
Superclass to Subclass

Explicit casting must be used when

casting an object from a superclass to a
subclass. This type of casting may not
always succeed.
Apple x = (Apple)Fruit; //Fruit is superclass

Orange x = (Orange)Fruit;

51
 TIP
To help understand casting, you may also
consider the analogy of fruit, apple, and
orange with the Fruit class as the
superclass for Apple and Orange. An
apple is a fruit, so you can always safely
assign an instance of Apple to a variable
for Fruit.
However, a fruit is not necessarily an
apple, so you have to use explicit casting
to assign an instance of Fruit to a variable
of Apple.
52