Transcript Inheritance

Inheritance in Java
What is inheritance (in Java)?
• Inheritance is a mechanism
for enhancing existing
classes
• What does that mean…?
• Defining new classes,
which build on the functionality of existing classes
RHS – SOC
2
What is inheritance (in Java)?
• Suppose we have a BankAccount class,
which provides basic functionality common
for all types of bank accounts
– Depositing money
– Withdrawing money
– Retrieving the balance
• But most bank accounts have more
functionality that just this…
RHS – SOC
3
What is inheritance (in Java)?
Checking Account
Monthly fee
Transaction fee
Bank
Account
RHS – SOC
Savings Account
Monthly interest
Upper balance limit
4
What is inheritance (in Java)?
BankAccount
- balance
+ deposit
+ withdraw
+ getBalance()
CheckingAccount
SavingsAccount
- rate
- chargeMonthlyFee()
- chargeTransFee()
- depositInterest()
- checkBalanceLimit()
RHS – SOC
5
Inheritance in code
public class SavingsAccount extends BankAccount
{
private double rate;
public SavingsAccount(double rate) {...}
public void depositInterest() {...}
public bool checkBalanceLimit() {...}
}
RHS – SOC
6
Inheritance
• We only need to define the new methods
and instance fields for SavingsAccount
• Methods and instance fields from
BankAccount are inherited
• We extend the BankAccount class
without touching it (code reuse)
• ”Closed for modification, open for
extension”
RHS – SOC
7
Inheritance
BankAccount
- balance
Superclass
+ deposit
+ withdraw
+ getBalance()
SavingsAccount
Subclass
- rate
- depositInterest()
- checkBalanceLimit()
RHS – SOC
8
Inheritance
• Why is the class with most functionality
called the subclass?
• Terminology from set theory
BankAccount
Checking
Account
Savings
Account
RHS – SOC
9
Inheritance vs. Interfaces
• Related, but not the same
• If you must implement an
interface, you are ”ordered”
to implement a set of
certain methods
• If you extend a class, you
get something ”for free”
RHS – SOC
10
Inheritance vs. Interfaces
• One quite important difference between
inheritance and interfaces:
– A class can implement multiple interfaces
– A class can only extend one class
– There is no such thing as multiple inheritance
in Java…
– Multiple inheritance has issues, taken out of
Java to keep things simple
RHS – SOC
11
Inheriting methods
• A subclass has three
options when defining
methods:
– Inherit methods as-is
– Override methods
– Define new methods
(just as we are used to)
RHS – SOC
12
Inheriting methods
• Inherit methods as-is
• Just as it sounds – the method will work
exactly as it works in the superclass
• Methods can (still) be applied to objects of
the superclass, and also to objects of the
subclass
RHS – SOC
13
Inheriting methods
• Override methods
• We can actually provide a different implementation of a method from the superclass
• Superclass may provide a reasonable
default implementation
• Subclasses may substitute it for a more
useful implementation
RHS – SOC
14
Inheriting methods
public class DefaultShape
{
public void draw() { // do nothing }
public double getArea() { return 0.0;}
}
RHS – SOC
15
Inheriting methods
public class Circle extends DefaultShape
{
// new instance fields, etc.
public void draw() // Override
{
// code for drawing a Circle
}
public double getArea() // Override
{
return (radius*radius*Math.PI);
}
}
RHS – SOC
16
Inheriting methods
public class Point extends DefaultShape
{
// new instance fields, etc.
public void draw() // Override
{
// code for drawing a Point
}
// However, I keep implementation of getArea
}
RHS – SOC
17
Inheriting methods
DefaultShape ds = new DefaultShape();
double area1 = ds.getArea();
Circle c = new Circle(1,1,1);
double area2 = c.getArea();
Point p = new Point(1,1);
double area3 = p.getArea();
DefaultShape dsc = new Circle(2,2,2);
double area4 = ds.getArea();
RHS – SOC
18
Inheriting methods
• ”In Java, method calls are
always determined by the
type of the actual object,
not the type of the object
reference”
• This is polymorphism
RHS – SOC
19
Inheriting methods
• What if we want to ”supplement” a method, not
override it completely
• Do we need to implement
all of the code in the superclass again?
• No – and it would break
encapsulation!
RHS – SOC
20
Inheriting methods
// Original method from BankAccount
public void deposit(double amount)
{
balance = balance + amount;
}
// Overridden method in CheckingAccount
public void deposit(double amount)
{
balance = balance + amount;
transactionCount++;
}
Ooops!
RHS – SOC
21
Inheriting methods
// Overridden method in CheckingAccount
public void deposit(double amount)
{
super.deposit(amount);
New keyword!
transactionCount++;
}
• ”Do what the superclass does in deposit,
then do my stuff”
RHS – SOC
22
Inheriting methods
• We can also do this for constructors!
// Constructor for subclass
public CheckingAccount(double initialBalance)
{
super(initialBalance);
// Now do initialisation specific for
// the CheckingAccount class
transactionCount = 0;
}
RHS – SOC
23
Conversions
• Rules for conversion between super- and
sub-class are similar to conversion rules
between interfaces and implementation
class
– Always legal to convert to a superclass
– Legal – but risky – to cast from superclass to
subclass
RHS – SOC
24
Conversions
• In other words:
DefaultShape s1 = new Square(10,10,10); // OK
DefaultShape s2 = new Point(20,20);
Circle c = new Circle(5,10,20);
// OK
// OK
DefaultShape s = new DefaultShape();
Circle c = new DefaultShape();
Square sq = new Circle(5,20,40);
// OK (!)
// NO!
// NO!
RHS – SOC
25
Conversions
• And this is still dangerous!
public void enlarge(DefaultShape s)
{
Circle c = (Circle)s; OK – if s is a Circle!
double r = c.getRadius();
c.setRadius(2*r);
}
RHS – SOC
26
Exercises
• Self-check: 1, 3, 10, 11
• Review: R10.3, R 10.7
• Programming: P10.4
RHS – SOC
27