Object-Oriented Programming

Unit 5. Inheritance and Polymorphism

Outline
1. Overriding Methods (revisit)
2. Creating a Subclass
2.1 Observations
2.2 Constructors in Subclass
2.3 The “super” Keyword
2.4 Using SavingAcct
2.5 Method Overriding
2.6 Using “super” Again
3. Subclass Substitutability
4. The “Object” Class
5. “is-a” versus “has-a”
6. Preventing Inheritance (“final”)
7. Polymorphism

[CMP167 - Unit 5-Inheritance and Polymorphism]

2
0. Object-Oriented Programming
◼ Four fundamental concepts of OOP:
❑ Encapsulation (đóng gói)
❑ Abstraction (trừu tượng)
❑ Inheritance (kế thừa)
❑ Polymorphism (đa hình)
◼ Inheritance allows new classes to inherit
properties of existing classes
◼ Main concepts in inheritance
❑ Subclassing
❑ Overriding

[CMP167 - Unit 5-Inheritance and Polymorphism]

3
1. Overriding Methods (revisit) (1/2)
◼ Recall in lecture #3 that a user-defined class
automatically inherits some methods – such as
toString() and equals() – from the Object class
◼ The Object class is known as the parent class (or
superclass); it specifies some basic behaviours
common to all kinds of objects, and hence these
behaviours are inherited by all its subclasses
(derived classes)
◼ However, these inherited methods usually don’t
work in the subclass as they are not customised

[CMP167 - Unit 5-Inheritance and Polymorphism]

4
1. Overriding Methods (revisit) (2/2)
◼ Hence, to make them work, we customised these
inherited methods – this is called overriding
Lecture #3: MyBall/MyBall.java
/***************** Overriding methods ******************/
// Overriding toString() method
public String toString() {
return "[" + getColour() + ", " + getRadius() + "]";
}
// Overriding equals() method
public boolean equals(Object obj) {
if (obj instanceof MyBall) {
MyBall ball = (MyBall) obj;
return this.getColour().equals(ball.getColour()) &&
this.getRadius() == ball.getRadius();
}
else
return false;
}
}
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
5
2. Creating a Subclass (1/6)
◼ Object-oriented languages allow inheritance
❑ Declare a new class based on an existing class
❑ So that the new class may inherit all of the attributes
and methods from the other class
◼ Terminology (thuật ngữ)
❑ If class B is derived from class A, then class B is called
a child (or subclass or derived class) of class A
❑ Class A is called a parent (or superclass) of class B

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
6
2. Creating a Subclass (2/6)
◼ Recall the BankAcct class in lecture #3
lect3/BankAcct.java
class BankAcct {
private int acctNum;
private double balance;
public BankAcct() { }
public BankAcct(int aNum, double bal) { ... }
public int getAcctNum() { ... }
public double getBalance() {... }
public boolean withdraw(double amount) { ... }
public void deposit(double amount) { ... }
public void print() { ... }
}
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
7
2. Creating a Subclass (3/6)
◼ Let’s define a SavingAcct class
◼ Basic information:
❑ Account number, balance
❑ Interest rate
New requirements
◼ Basic functionality:
❑ Withdraw, deposit
❑ Pay interest
◼ Compare with the basic bank account:
❑ Differences are highlighted above
❑ SavingAcct shares more than 50% of the code with BankAcct
◼ So, should we just cut and paste the code from BankAcct
to create SavingAcct?
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
8
2. Creating a Subclass (4/6)
◼ Duplicating code is undesirable (không mong
muốn) as it is hard to maintain
❑ Need to correct all copies if errors are found
❑ Need to update all copies if modifications are required
◼ Since the classes are logically unrelated if the
codes are separated:
❑ Code that works on one class cannot work on the other
◼ Compilation errors due to incompatible (không
tương thích) data types
◼ Hence, we should create SavingAcct as a
subclass of BankAcct
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
9
2. Creating a Subclass (5/6)
BankAcct.java
class BankAcct {
The “protected” keyword
protected int acctNum;
allows subclass to access
protected double balance;
the attributes directly
//Constructors and methods not shown

}
The “extends”
class SavingAcct extends BankAcct { keyword indicates
inheritance
protected double rate; // interest rate

public void payInterest() {

balance += balance * rate;
} This allows subclass of SavingAcct to
access rate. If this is not intended,
} you may change it to “private”. SavingAcct.java
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
10
2. Creating a Subclass (6/6)
◼ The subclass-superclass relationship is known as an
“is-a” relationship, i.e., SavingAcct is-a BankAcct
◼ In the UML diagram, a solid line with a closed unfilled
arrowhead is drawn from SavingAcct to BankAcct
◼ The symbol # is used to denoted protected member
SavingAcct BankAcct
# acctNum
# rate
# balance

+ getRate() + getAcctNum()
+ payInterest() + getBalance()
+ print() + withdraw()
+ deposit()
+ print()

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
11
2.1 Observations
◼ Inheritance greatly reduces the amount of
redundant coding
◼ In SavingAcct class,
❑ No definition of acctNum and balance
❑ No definition of withdraw() and deposit()
◼ Improve maintainability:
❑ Eg: If a method is modified in BankAcct class, no
changes are needed in SavingAcct class
◼ The code in BankAcct remains untouched
❑ Other programs that depend on BankAcct are
unaffected  very important!
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
12
 2.2 Constructors in Subclass
◼ Unlike normal methods, constructors are NOT
inherited
❑ You need to define constructor(s) for the subclass
class SavingAcct extends BankAcct {
protected double rate; // interest rate
public SavingAcct(int aNum, double bal, double rate){
acctNum = aNum;
balance = bal;
this.rate = rate;
}

//......payInterest() method not shown

}
SavingAcct.java

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
13
 2.3 The “super” Keyword
◼ The “super” keyword allows us to use the methods
(including constructors) in the superclass directly
◼ If you make use of superclass’ constructor, it must be the
first statement in the method body
class SavingAcct extends BankAcct {
protected double rate; // interest rate
public SavingAcct(int aNum, double bal, double rate){
super(aNum, bal); Using the constructor
this.rate = rate; in BankAcct class
}

//......payInterest() method not shown

}
SavingAcct.java
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
14
 2.4 Using SavingAcct
TestSavingAcct.java
public class TestSavingAcct {

public static void main(String[] args) {

SavingAcct sa1 = new SavingAcct(2, 1000.0, 0.03);

sa1.print();
sa1.withdraw(50.0); Inherited method from BankAcct

sa1.payInterest(); Method in SavingAcct

sa1.print();
}
} How about print()?
Should it be the one in BankAcct class,
or should SavingAcct class override it?

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
15
2.5 Method Overriding (1/2)
◼ Sometimes we need to modify the inherited method:
❑ To change/extend the functionality
❑ As you already know, this is called method overriding
◼ In the SavingAcct class:
❑ The print() method inherited from BankAcct should be
modified to include the interest rate in output
◼ To override an inherited method:
❑ Simply recode the method in the subclass using the
same method header
❑ Method header refers to the name and parameters type
of the method (also known as method signature)

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
16
2.5 Method Overriding (2/2)
class SavingAcct extends BankAcct { SavingAcct.java

protected double rate; // interest rate

public double getRate() { return rate; }
public void payInterest() { ... }
public void print() {
System.out.println("Account Number: " + getAcctNum());
System.out.printf("Balance: $%.2f\n", getBalance());
System.out.printf("Interest: %.2f%%\n", getRate());
}
}

◼ The first two lines of code in print() are exactly the

same as print() of BankAcct
❑ Can we reuse BankAcct’s print() instead of recoding?
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
17
 2.6 Using “super” Again
◼ The super keyword can be used to invoke superclass’
method
❑ Useful when the inherited method is overridden

SavingAcct.java
class SavingAcct extends BankAcct {
. . .
To use the print()
public void print() { method from BankAcct
super.print();
System.out.printf("Interest: %.2f%%\n", getRate());
}
}

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
18
Exercise

[CMP167 - Unit 5-Inheritance and Polymorphism]

19
3. Subclass Substitutability (1/2)
◼ An added advantage for inheritance is that:
❑ Whenever a super class object is expected, a sub class
object is acceptable as substitution (sự thay thế)!
◼ Caution: the reverse is NOT true (Eg: A cat is an animal;
but an animal may not be a cat.)
❑ Hence, all existing functions that works with the super
class objects will work on subclass objects with no
modification!
◼ Analogy (phép loại suy):
❑ We can drive a car
❑ Honda is a car (Honda is a subclass of car)
❑ We can drive a Honda
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
20
 3. Subclass Substitutability (2/2)
TestAcctSubclass.java
public class TestAcctSubclass {
public static void transfer(BankAcct fromAcct,
BankAcct toAcct, double amt) {
fromAcct.withdraw(amt);
toAcct.deposit(amt);
};
public static void main(String[] args) {

BankAcct ba = new BankAcct(1, 234.56);

SavingAcct sa = new SavingAcct(2, 1000.0, 0.03);
transfer(ba, sa, 123.45);
ba.print();
sa.print();
transfer() method can work
} on the SavingAcct object sa!
}
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
21
4. The “Object” Class
◼ In Java, all classes are descendants of (con cháu
của) a predefined class called Object
❑ Object class specifies some basic behaviors common
to all objects
❑ Any methods that works with Object reference will
work on object of any class
❑ Methods defined in the Object class are inherited in all
classes
❑ Two inherited Object methods are
◼ toString() method
◼ equals() method
❑ However, these inherited methods usually don’t work
because they are not customised
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
22
5. “is-a” versus “has-a” (1/2)
◼ Words of caution:
❑ Do not overuse (không lạm dụng) inheritance
❑ Do not overuse protected
◼ Make sure it is something inherent for future subclass

◼ To determine whether it is correct to inherit:

❑ Use the “is-a” rules of thumb
◼ If “B is-a A” sounds right, then B is a subclass of A
❑ Frequently confused with the “has-a” rule
◼ If “B has-a A” sounds right, then B should have an A
attribute (hence B depends on A)

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
23
5. “is-a” versus “has-a” (2/2)
◼ UML diagrams
class BankAcct {
...
}
SavingAcct BankAcct
class SavingAcct extends BankAcct {
...
}
Solid arrow
Inheritance: SavingAcct IS-A BankAcct

class BankAcct {
...
}; Person BankAcct
class Person {
private BankAcct myAcct;
}; Dotted arrow
Attribute: Person HAS-A BankAcct
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
24
6. Preventing Inheritance (“final”)
◼ Sometimes, we want to prevent inheritance by
another class (eg: to prevent a subclass from corrupting the
behaviour of its superclass)
◼ Use the final keyword
❑ Eg: final class SavingAcct will prevent a subclass to be
created from SavingAcct
◼ Sometimes, we want a class to be inheritable, but
want to prevent some of its methods to be overridden
by its subclass
❑ Use the final keyword on the particular method:
public final void payInterest() { … }
will prevent the subclass of SavingAcct from overriding
payInterest()
[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
25
Exercise
◼ Create 3 classes:
Person, Student and
Undergraduate class

[CMP167 - Unit 5-Inheritance and Polymorphism]

26
7. Polymorphism
◼ Inheritance allows you to define a base class
and derive classes from the base class
◼ Polymorphism allows you to make changes in
the method definition for the derived classes
and have those changes apply to methods
written in the base class

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
27
 Polymorphism
◼ Consider an array of Person
Person[] people = new Person[4];

◼ Since Student and

Undergraduate are types of
Person, we can assign them
to Person variables

people[0] = new
Student("DeBanque, Robin",
8812);

people[1] = new
Undergraduate("Cotty, Manny",
8812, 1);

[CMP167 - Unit 5-Inheritance and Polymorphism]

28
Polymorphism
◼ Given:
Person[] people = new Person[4];
people[0] = new Student("DeBanque, Robin",
8812);
◼ When invoking:
people[0].writeOutput();
◼ Which writeOutput() is invoked, the one
defined for Student or the one defined for
Person?
◼ Answer: The one defined for Student

[CMP167 - Unit 5-Inheritance and Polymorphism]

29
Exercise
◼ Creating the array of
04 people and
assigning person,
student, and
undergraduate.
◼ Using for loop and call
writeOutput for each
element.

[CMP167 - Unit 5-Inheritance and Polymorphism]

30
Exercise 2
◼ Creating the array of 05 people and assigning person,
student, and staff.
◼ Using for loop
and call toString
for each element.

[CMP167 - Unit 5-Inheritance and Polymorphism]

31
Exercise 3

[CMP167 - Unit 5-Inheritance and Polymorphism]

32
Exercise 4

[CMP167 - Unit 5-Inheritance and Polymorphism]

33
Exercise 5

[CMP167 - Unit 5-Inheritance and Polymorphism]

34
Summary
◼ Inheritance:
❑ Creating subclasses
❑ Overriding methods
❑ Using “super” keyword
❑ The “Object” class
◼ Polymorphism

[CMP167
[501043 Lecture
- Unit 5-Inheritance
5: Inheritance]
and Polymorphism]
35
End of file