Meeting 5: Inheritance and

Polymorphism

Edited by: Dr. Bayan Abu Shawar

AOU-Jordan

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
 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.
 To explore the equals() method in the Object class.

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.

Aggregating Aggregated
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: java.util.Date 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
+setColor(color: String): void
Returns the color.
Sets a new color.
SimpleGeometricObject
+isFilled(): boolean Returns the filled property.
+setFilled(filled: boolean): void Sets a new filled property. Circle
+getDateCreated(): java.util.Date 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)
+setRadius(radius: double): void +getWidth(): double
+getArea(): double +setWidth(width: double): void Run
+getPerimeter(): double +getHeight(): double
+getDiameter(): double +setHeight(height: double): void
+printCircle(): void +getArea(): double
+getPerimeter(): double

16
 Example: SimpleGeometricObject Class

import java.util.Date;
public class SimpleGeometricObject { public boolean isFilled()
private String color = "white"; { return filled; }
private boolean filled;
private Date dateCreated; public void setFilled(boolean
filled) { this.filled = filled;}
public SimpleGeometricObject() {
dateCreated = new java.util.Date(); public Date getDateCreated()
} {
public SimpleGeometricObject(String return dateCreated;
color, boolean filled) { }
dateCreated = new Date();
this.color = color; public String toString() {
this.filled = filled; return "created on " +
} dateCreated +
public String getColor() { return "\ncolor: " + color +
color; } " and filled: " +
filled;
public void setColor(String color) }
{this.color = color;}
}
 Continue: Circle class
public class Circle extends
SimpleGeometricObject { public double getArea()
private double radius; { return radius * radius *
Math.PI; }
public Circle() { }
public double getDiameter()
public Circle(double radius)
{ return 2 * radius; }
{ this.radius = radius; }
public double getPerimeter()
public Circle(double radius, String
{ return 2 * radius * Math.PI; }
color, boolean filled)
{ this.radius = radius;
public void printCircle() {
setColor(color);
System.out.println("The circle
setFilled(filled); }
is created " + getDateCreated()
public double getRadius()
+ " and the radius is " +
{ return radius; }
radius);
public void setRadius(double radius) }
{ this.radius = radius; } }
 Continue: Class Rectangle
public class Rectangle extends
SimpleGeometricObject {
public void setWidth(double width)
private double width, height;
{ this.width = width; }
public Rectangle() { } public double getHeight()
public Rectangle( double w, double h) { return height; }

public void setHeight(double height)

{ this.width = w; this.height = h; }

public Rectangle( double w, double h, { this.height = height; }

String color, boolean filled)
public double getArea()
{ this.width = w; this.height = 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);
System.out.println("A circle " + circle.toString());
System.out.println("The color is " + circle.getColor());
System.out.println("The radius is " + circle.getRadius());
System.out.println("The area is " + circle.getArea());
System.out.println("The diameter is " + circle.getDiameter());

Rectangle rectangle = new 2, 4);

System.out.println("\n A rectangle " + rectangle.toString());
System.out.println("The area is " + rectangle.getArea());
System.out.println("The perimeter is " + rectangle.getPerimeter());
}
}
 Are superclass’s Constructor
Inherited?
No. They are not inherited.
They are invoked explicitly or implicitly.
Explicitly using the super() keyword.
oA constructor is used to construct an instance of a class.
Unlike properties and methods, a superclass's constructors are
not inherited in the subclass.
oThey can only be invoked from the subclasses' constructors,
using the keyword super().
oIf the keyword super() is not explicitly used, the superclass's
no-arg constructor is automatically 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: super()

 To call a superclass method: super.method()

23
 CAUTION

You must use the keyword super to call

the superclass constructor. Invoking a
superclass constructor’s name in a
subclass causes a syntax error. Java
requires that the statement that uses the
keyword super appear first in the
constructor.
24
 Example on the Impact of a Superclass
without no-arg Constructor
Find out the errors in the program:
public class Apple extends Fruit {
}
 
public class Fruit {
public Fruit(String name) {
System.out.println("Fruit's constructor is invoked");
}
}

25
 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

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

public void printCircle() {

System.out.println("The circle is
created " + super.getDateCreated() +
" and the radius is " + radius);
}

27
 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 super.toString() + "\nradius is " + radius;
}
}

28
 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. 29
 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.
30
 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) {
System.out.println(i * 2); System.out.println(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) {
System.out.println(i); System.out.println(i);
} }
} }

32
 Overriding
public class Parent{ public class Test{
public void method(int i) public static void main()
{ System.out.println(“parent:”+i);} { Parent p = new Parent();
} Child c = new Child();
public class Child extends Parent { Parent k = new Child();
public void method(int i) p.method(2);
{ System.out.println(“child:”+i*2);} c.metod(2);
} k.method(2);
}
}

The output is:

parent 2
child 4
child 4
 Access modifiers
There are three keywords associated with controlling levels of access to class members
in Java: public, protected & private. These are known as access modifiers.

There is actually a fourth level of access, 'default'. There is no 'default‘ keyword;

default access arises when none of the access modifiers is specified.

The following example illustrates the accessibility:

Example:

Visibility for a ref. var. defined in Alpha

34
 Visibility Modifiers and
Accessor/Mutator Methods
By default, the class, variable, or method can be
accessed by any class in the same package.
 public
The class, data, or method is visible to any class in any package using
qualified name (a reference and a dot notation).
 private
The data or methods can be accessed only by the declaring class. The get and
set methods are used to read and modify private properties.
 Protected
The data or methods are accessible inside class where they are declared, and
inside subclasses. All class in the same package can access protected member
using qualified name.
 No modifier: default members can be accessed by all classes in the same 35
package using qualified name
The private modifier restricts access to within a class, the default modifier
restricts access to within a package, and the public modifier enables unrestricted
access.

36
The default modifier on a class restricts access to within a package, and the
public modifier enables unrestricted access.

37
 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

38
 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 - - -

39
 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();
} } }

40
 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.
41
 NOTE

The modifiers are used on classes and

class members (data and methods), except
that the final modifier can also be used on
local variables in a method.
A final local variable is a constant inside
a method.

42
 The final Modifier
 The final class cannot be extended:
final class Math {
...
}

 The final variable is a constant:

final static double PI = 3.14159;

 The final method cannot be

overridden by its subclasses.

43
 The Object Class and Its Methods
Every class in Java is descended from the
java.lang.Object 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
...
} }

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

System.out.println(loan.toString());

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.
45
 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) {

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. }

46
 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.
47
 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) {
System.out.println("The circle diameter is " +
((Circle)myObject).getDiameter());
...
}

48
 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
51
 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) {
System.out.println(x.toString()); 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 { an instance of GraduateStudent, Student, Person, or
public String toString() {
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
52
java.lang.Object@b8bef7
 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, …,
53
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.

54
 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) {
System.out.println(x.toString()); 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
}
  method, the particular implementation
class Person extends Object {
public String toString() {
of the method of the object that is
return "Person"; invoked (e.g., toString) is determined
}
} dynamically.

55
 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.
56
 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
57
 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;

58
 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.
59
Please Solve the Activity of Meeting 5.

60