lesson 8

8. Inheritance and

Interfaces

To learn about

inheritances

To be able to convert

between supertype

and subtype

references

To understand how to

override superclass

methods

To understand the

concept of

polymorphism

To design and use

abstract classes and

interfaces

To learn about

packages and Java

access control

Introduction to

Inheritance

Inheritance is a

mechanism for

enhancing existing,

working class.

For example, suppose

we need to define a

class SavingsAccount

to model an account

that pays a fixed

interest rate on

deposits.

class SavingsAccount

extends BankAccount

{ new instance variables

new methods

}

class SubclassName

extends SuperclassName

{ new instance variables

new methods

}

Inheritance

The more general

class that forms the

basis for inheritance is

called the superclass.

The more specialized

class that inherits from

the superclass is

called the subclass.

One important reason

for inhertance is code

reuse.

Inheritance Diagram

Object <---
BankAccount <----
SavingsAccount
Inheritance Diagram
Which class is a
superclass and which
class is a subclass?
BankAccount is the
superclass and
SavingsAccount is the
subclass.
Suppose we want to
set an interest rate in
the constructor for
SavingsAccount class
and also a method to
apply that interest rate
periodically.
public class
SavingsAccount extends
BankAccount
{ private double
interestRate;
public SavingsAccont
(double rate)
{ constructor
implementation }
public void addInterest
( )
{ method
implementation }
}
public class
BankAccount
{ private double
balance;
public BankAccount( )
{ balance = 0; }
public BankAccount
(double init )
{ balance = init; }
public void deposit
(double amount)
{ balance = balance +
amount; }
public void withdraw
(double amount)
{ balance = balance -
amount; }
public double
getBalance( )
{ return balance; }
}
public class
SavingsAccount
extends BankAccount
{ private double
interestRate; //
instance variable
public SavingsAccont
(double rate) //
constructor
{ interestRate = rate; }
public void addInterest
( ) // instance method
{ double interest =
getBalance() *
interestRate / 100;
deposit(interest);
}
}
// Example Code
SavingsAccount
collegeFund = new
SavingsAccount(10);
collegeFund.deposit
(500); // OK to use
superclass’s method
collegeFund.
addInterest( );
Converting Between
Class Types
A SavingsAccount
object is a special
case of a BankAccount
object. So, you can
store a reference to a
SavingsAccount object
into a BankAccount
object.
SavingsAccount
collegeFund = new
SavingsAccount(10);
BankAccount anAccount =
collegeFund;
Object anObject =
collegeFund;
The three object
references stored in
collegeFund,
anAccount, and
anObject refer to the
same object of type
SavingsAccount.
However, the
anAccount knows less
than the full story
about the object to
which it refers
anAccount.deposit(1000)
; // OK
anAccount.addInterest( )
; // Not OK
Because anAccount is
an object of type
BankAccount, we
cannot use the
addInterest method.
anObject.deposit(1000); //
Not OK
The variable anObject
knows even less,
because it is an object
of type Object and
deposit is not a
method of the object
class.
Why would anyone
want to know less
about an object and
store a reference in an
object variable of a
superclass? Reuse.
Consider the transfer
method
void transfer(BankAccount
other, double amount)
{ withdraw(amount);
other.deposit(amount);
}
We can use this
method to transfer
money from one bank
account to another:
BankAccount
momsChecking = … ;
BankAccount
harrysChecking = … ;
momsChecking.transfer
(harrysChecking, 1000);
We can also use this
method to transfer
money into a
SavingAccount:
SavingsAccount
CollegeFund = … ;
momsChecking.
transfer(collegeFund,
1000);
However, we cannot
convert between
unrelated classes:
Rectangle r =
CollegeFund; // Error
Subclass reference can
be assigned to
superclass reference
Object anObject =
collegeFund;
But, superclass
reference must be
casted to subclass
reference.
SavingsAccount x =
(SavingsAcount)anObject;
as long as we
absolutely sure that
anObject really refers
to a SavingsAccount
object.
To play it safe, we can
use the instanceof
operator to test
whether an object
belongs to a particular
class (or one of its
subclasses).
Object instanceof
ClasssName
Rectangle r;
if (x instanceof
Rectangle)
r = (Rectangle) x;
SavingsAccount x;
if (anObject instanceof
SavingsAccount)
x = (SavingsAccount)
anObject;
else
x = null;
Hierarchies
Hierarchies are
frequently represented
as trees, with the
most general concepts
at the root.
In Java, it is common
to group classes in
inheritance
hierarchies.
Inheritance
Hierarchies
The classes
representing the most
general concepts are
near the root, more
specialized classes
towards the branches.
When designing a
hierarchy of classes,
those common
properties are
collected in a
superclass. More
specialized properties
can be found in
subclasses.
Consider a bank that
offers its customers
three kinds of
accounts:
CheckingAccount
SavingsAccount
TimeDepositAccount
The checking account
has no interest, gives
you a small number of
free transactions per
month, and charges a
transaction fee for
each additional
transactions.
The savings account
compounds interest
monthly.
The time deposit
account has a penalty
for early withdrawal.
The inheritance
hierarchy for these
account classes is:
protected Members
A superclass’s public
members are
accessible anywhere
the program has a
reference to that
superclass type or one
of its subclasses
types.
A superclass’s private
members are
accessible only in
methods of that
superclasses.
A superclass’s
protected members
serve as an
intermediate level of
protection between
public and private
access.
protected Members
A superclass’s
protected members
can be accessed by
methods of the
superclass, by
methods of subclasses
and by methods of
other classes in the
same package
(protected members
have package access).
Subclass methods can
normally refer to public
and protected
members of the
superclass simply by
using the member
names.
Inheritance
// Definition of a class
Point
public class Point {
protected int x, y;
public Point()
{ setPoint(0,0); }
public Point(int a, int b)
{ setPoint(a, b); }
public void setPoint(int
a, int b)
{ x = a;
y = b;
}
public int getX()
{ return x; }
public int getY()
{ return y; }
public String toString()
{ return “[“ + x + “, “ + y
+ “]”; } }
// Definition of class
circle
public class Circle
extends Point {
protected double
radius;
public Circle()
{ // implicit call to
superclass constructor
setRadius(0); }
public Circle(double r,
int a, int b)
{ super(a, b);
setRadius(r);
}
public void setRadius
(double r)
{ radius = (r >= 0.0 ? r :

0.0); }

pubic double getRadius

()

{ return radius; }

public double area()

{ return Math.PI *

radius * radius; }

public String toString()

{ return “Center = “ +

“[“ + x + “,” + y + “]” +

“; Radius = “ + radius;

}

}

// Main program

import java.text.

DecimalFormat;

import javax.swing.

JOptionPane;

public class

InheritanceTest {

public static void main

(String[] args)

{ Point pointRef, p;

Circle circleRef, c;

String output;

p = new Point(30,50);

c = new Circle(2.7, 120,

89);

output = “Point p: “+

p.toString() +

“\nCircle c: “ +

c.toString() ;

pointRef = c;

output += “\n\nCircle c

(via pointRef): “ +

pointRef.toString() ;

circleRef = (Circle)

pointRef;

output += “\n\nCircle c

(via circleRef): “ +

circleRef.toString() ;

DecimalFormat

precision2 = new

DecimalFormat(“0.00”)

;

output += “\n\nArea of

c (via circleRef): “ +

precision2.format

(circleRef.area());

if (p instanceof Circle)

{

circleRef = (Circle) p;

output += “\n\ncast

successful”;

}

else

output += “\n\n p does

not refer to a circle”;

JOptionPane.

showMessageDialog

(null, output,

“Inheritance”,

JOptionPane.

INFORMATION_

MESSAGE);

System.exit(0);

}

}

Inheriting Instance

Variables and Methods

When defining

additional methods for

a subclass, there are 3

options:

1. We can override

methods from the

superclass by

specifying a method

with the same

signature (i.e., the

same name and the

same parameters).

2. We can inherit

methods from the

superclass. If we do

not explicitly override

a superclass method,

we automatically

inherit it.

3. We can define new

methods that does not

exist in the superclass.

When defining

additional instance

variables for a

subclass, there are 2

options:

1. We can inherit

variables from the

superclass.

2. We can define new

variables. These new

variables are only

presented in subclass

objects.

Remember! We can

never override

instance variables.

Shadowing

The newly defined

subclass variable

shadows the

superclass variable.

The superclass

variable is still

present, but it cannot

be accessed.

When you refer to

balance in a

SavingAccount

method, you access

the new instance

variable.

Shadowing instance

variables is harmless.

Shadowing Instance

Variables

A subclass has no

access to the private

instance of the

superclass

public class

CheckingAccount

extends BankAccount

{ public void deposit

(double amount)

{ transactionCount++;

balance = balance +

amount; // ERROR

}

}

To solve the problem

public class

CheckingAccount

extends BankAccount

{ private double

balance; // shadow

variable

public void deposit

(double amount)

{ transactionCount++;

balance = balance +

amount; // OK but

different balance

}

}

Example

public class

BankAccount

{ private double

balance;

public double

getBalance() {…}

public void deposit

(double amount) {…}

public void withdraw

(double amount) {…}

}

public class

CheckingAccount

extends BankAccount

{ private int

transactionCount;

public void deposit

(double amount) {…}

public void withdraw

(double amount) {…}

public void deductFees

() {…}

}

Subclass methods

have no access rights

to the private data of

the superclass.

If we want to modify a

private superclass

variable, we must use

a public method of the

superclass.

Can we write the

deposit method as

public void deposit

(double amount)

{ transactionCount++;

deposit(amount); // Is

it OK?

}

If we define the

method like that, it will

call itself infinitely.

We need to be more

specific that we want

to invoke the

superclass’s deposit

method by using a

special keyword super

for this purpose:

public void deposit

(double amount)

{ transactionCount++;

super.deposit(amount);

}

Calling a Superclass

Methods

public class

CheckingAccount

extends BankAccount

{ private static final int

FREE_TRANSANCTIONS

= 3;

private static final

double TRANSACTION_

FEE = 2.0;

public void withdraw

(double amount) //

override method

{ transactionCount++;

super.withdraw

(amount); // calling a

superclass method.

// what if we call

withdraw(amount);

}

public void deductFees

( )

{ if (transactionCount >

FREE_TRANSACTIONS)

{ double fees =

TRANSACTION_FEE

* (transactionCount -

FREE_TRANSACTIONS);

super.withdraw(fees);

}

}

Now, let consider the

TimeDepositAccount

class, a subclass of the

SavingsAccount:

public class

TimeDepositAccount

extends

SavingsAccount

{ private int

periodsToMaturity;

private static final

double EARLY_

PENALTY= 20.0;

public void addInterest

( )

{ periodsToMaturity- - ;

super.addInterest( );

}

public void withdraw

(double amount)

{ if (periodsToMaturity

> 0)

super.withdraw(EARLY_

PENALTY);

super.withdraw

(amount);

}

}

The

TimeDepositAccount

is two levels away

from the BankAccount.

The BankAccount is a

superclass, but not the

immediate superclass.

The

TimeDepositAccount

inherits two methods

from the BankAccount

class, namely

getBalance, and

deposit.

Methods can be

inherited from an

indirect superclass as

long as none of the

intermediate

superclasses

overrides them.

The method call

super.addInterest in

addInterest method of

the

TimeDepositAccount

refers to the

addInterest method in

SavingsAccount class.

The super.withdraw in

the withdraw method

of the

TimeDepositAccount

refers to the withdraw

method in

BankAccount.

Subclass Construction

Calling a Superclass

Constructor

ClassName

(parameters)

{ super(parameters);

…

}

Call the superclass

constructor to set the

balance to the initial

balance

public class

CheckingAccount

extends BankAccount

{ public

CheckingAccount

(double init)

{ super(init);

transactionCount = 0;

}

}

The constructor call

must be the first

statement of the

subclass constructor.

Subclass Constructor

When the keyword

super is followed by a

parenthesis, it

indicates a call to the

superclass

constructor.

If super is followed by

a period and a method

name, it indicates a

call to a superclass

method.

Or, we can implement

the CheckingAccount

constructor without

calling the superclass

constructor as can be

seen in the following

example:

public class

CheckingAccount

extends BankAccount

{ public

CheckingAccount

(double init)

{ // use superclass’s

default constructor

super.deposit(init);

transactionCount = 0;

}

}

public class

TimeDepositAccount

extends

SavingsAccount

{ public

TimeDepositAccount

(double rate, int

maturity )

{ super(rate);

periodsToMaturity =

maturity ;

}

}

Subclass Construction

If a subclass

constructor does not

call the superclass

constructor, the

superclass is

constructed with its

default constructor.

If a superclass does

not have a default

constructor, then the

complier reports an

error.

For example,

CheckingAccount can

be implemented

without calling the

superclass

constructor.

The BankAccount class

is constructed with its

default constructor,

which set the balance

to zero.

Then the

CheckingAccount

constructor must

explicitly deposit the

initial balance.

public

CheckingAccount

(double init)

{ // use superclass’s

default constructor

super.deposit(init);

transactionCount = 0;

However, in the case

of

TimeDepositAccount,

the superclass,

SavingsAccount, has

no default constructor.

Thus, we must call the

superclass constructor

explicitly.

public

TimeDepositAccount

(double rate, int

maturity )

{ super(rate);

periodsToMaturity =

maturity ;

}

Polymorphism

“is-a” relationship:

Every object of the

subclass is also a

superclass object, but

with special

properties.

For example, every

CheckingAccount is a

BankAccount.

It is possible to use a

subclass object in

place of a superclass

object.

What is polymorphism?

Let’s consider the

transfer method that

can be used to transfer

money from another

account:

public void transfer

(BankAccount other,

double amount)

{ withdraw(amount);

other.deposit(amount);

}

BankAccount

collegeFund = … ;

CheckingAccount

harrysChecking = … ;

collegeFund.transfer

(harrysChecking, 1000)

;

Which deposit

method?

BankAccount.deposit( )

or CheckingAccount.

deposit( )

Consider the call to the

deposit method, the

other parameter has

type BankAccount.

On the other hand, the

CheckingAccount class

provides its own

deposit method that

updates the

transaction count.

Since the other

variable actually refers

to an object of the

subclass

CheckingAccount, it

would be appropriate if

the CheckingAccount.

deposit method was

called instead.

The principle that the

actual type of the

object determines the

method to be called is

called polymorphism.

In Java, method calls

are always determined

by the type of the

actual object, not the

type of the object

reference.

In Java, all instance

methods are

polymophic.

The term

“polymorphism”

comes from the Greek

words for “many

shapes”.

Program

AccountTest.java

public class AccountTest

{ public static void main

(String[] args)

{ SavingsAccount

momsSavings = new

SavingsAccount(0.5);

TimeDepositAccount

collegeFund =

new TimeDepositAccount

(1, 3);

CheckingAccount

harrysChekcing = new

CheckingAccount(0);

momsSavings.deposit

(10000);

collegeFund.deposit

(10000);

momsSavings.transfer

(harryschecking, 2000);

collegeFund.transfer

(harryschecking, 980);

harrysChecking.withdraw

(500);

harrysChecking.withdraw

(80);

harrysChecking.withdraw

(400);

endOfMonth

(momsSavings);

endOfMonth

(collegeFund);

endOfMonth

(harrysChecking);

printBalance(“mom’s

savings”,

momsSavings);

printBalance(“the

college Fund”,

collegeFund);

printBalance(“Harry’s

checking”,

harrysChecking);

}

public static void

endOfMonth

(SavingsAccount savings)

{ savings.addInterest

( ); }

public static void

endOfMonth

(CheckingAccount

checking)

{ checking.deductFees

( ); }

public static void

printBalance(String

name, BankAccount

account)

{ System.out.println

(“The balance of “ +

name + “ account is $”

+

account.getBalance( ) )

;

}

}

Polymorphism vs.

Overload

Let’s take a look at a

polymorphic method

call such as

other.deposit(amount),

there are several

deposit methods that

can be called.

Both polymorphic

deposit and withdraw

methods are called.

What happens when

the method name is

overloaded;i.e., when

a single class has

several methods with

the same name but

different parameter

types?

For example, we can

have two constructors

BankAccount() and

BankAccount(double).

The compiler selects

the appropriate

method when

compiling a program.

Another example of

overloading, the static

endOfMonth methods

in the AccountTest

class. The compiler

uses the type of the

explicit parameter to

pick the appropriate

method.

The main difference

between

polymorphism and

overloading is the

binding method.

Polymorphism uses a

selection method

called late binding, i.e.,

the compiler doesn’t

make any decision

when translating the

method, it is the virtual

machine that selects

the appropriate

method.

Overloading uses early

binding technique

which compiler picks

an overloaded method

when translating the

program.

Interfaces

Many object-oriented

programming

languages have

multiple inheritance,

i.e.,more than one

superclass.

In Java, a class cannot

have two direct

superclasses.

To support this

feature, we use

interfaces instead of

superclasses.

The purpose of

interfaces is to support

the concept of writing

a single method for

any data type.

Interfaces

An interface is similar

to a class, but

An interface does not

have instance

variables

All methods in an

interface are abstract;

they have a name,

parameters, and a

return type, but they

don’t have an

implementation.

All methods in an

interface are

automatically public.

The interface

declaration lists all

methods that the

interface requires.

For example, the

java.lang package

defines a Comparable

interface as:

public interface

Comparable

{ int compareTo(Object

other);

// no implementation

}

We don’t extend

interfaces; we

implement them, using

the special

implements keyword:

public class

SavingAccount extends

BankAccount

implements

Comparable

{ …

}

Any class that

implements the

Comparable interface

must supply the

compareTo method

public class

SavingsAccount

extends BankAccount

implements

Comparable

{ …

public int compareTo

(Object other)

{ // supply

implementation …

SavingsAccount

otherAcc =

(SavingsAccount)

other;

if (interestRate <
otherAcc.interestRate)
return -1;
if (interestRate >

otherAcc.interestRate)

return 1;

return 0;

} ...

}

Note that the class

must declare the

method as public,

whereas the interface

does not -- all methods

in an interface are

public.

Once a class

implements an

interface, you can

convert a class

reference to an

interface reference:

SavingsAccount

harrysSavings = new

SavingAccount();

Comparable first =

harrysSavings;

However, we can

never construct an

interface:

Comparable second; // OK

second = new

Comparable( ); // ERROR

All interface

references refer to

objects of other

classes-- classes that

implement the

interface.

first.compareTo(second);

A class can have only

one superclass, but it

can implement any

number of interfaces

public class

SavingsAccount

extends BankAccount

implements

Comparable, Cloneable

Constants in

Interfaces

public interface

SwingConstants

{ int NORTH = 1;

int NORTH_EAST = 2;

int EAST = 3;

…

}

// SwingConstants.

NORTH;

all variables in an

interface are

automatically public

static final

Abstract Classes

Abstract Classes : A

class which we cannot

create objects

public abstract class

BankAccount

{ publicabstract void

deductFees( );

…

}

The reason for using

abstract classes is to

force programmers to

create subclasses.

BankAccount

anAccount; // OK

anAccount = new

BankAccount(); // Error

anAccount = new

SavingsAccount(); //

OK

anAccount = null; // OK

Note that we can still

have an object

reference whose type

is an abstract class.

Abstarct classes differ

from interfaces -- they

can have instance

variables and concrete

methods.

Final Methods and

Classes: To prevent

others from creating

subclasses or from

overriding certain

methods

public final class String

{ …. }

public class MyApplet

extends Applet

{ publicfinal boolean

checkPasswd(String

passwd)

{ … }

}

Access Control

Java has four levels of

controlling access to

variables, methods,

and classes:

public access

private access

protected access

Package access (the

default, when no

access modifier is

given)

Proteced data can be

accessed by the

methods of a class and

all its subclasses.

public class

BankAccount

{ protected double

balance; }

If a superclass

declares a method to

be publicly accesible,

we cannot override it

to be more private.

public class BankAccount

{ public void withdraw

(double amount) { … } }

public class

TimeDepositAccount

extends BankAccount

{ private void withdraw

(double amount) { … } //

ERROR

}

Overriding Object

Superclass Methods

The methods of the

Object class are very

general:

- String toString( ) //

Returns a string

representation of the

object

- boolean equals

(Object other) // Test

whether the object

equals

// another object

- Object clone( ) //

Makes a full copy of an

object

Overriding the toString

Method

The toString method

returns a string

representation for

each object.

Rectangle x = new

Rectangle(5, 10, 20, 30);

String s = x.toString( ); //

set s to

“java.awt.Rectangle[x=5,

// y=10,

width=20,height=30]”

The toString method is

called whenever we

concatenate a string

with an object.

System.out.println(“x

means ” + x); // will print

“x means

// java.awt.Rectangle

[x=5,y=10,width=20,height

=30]”

Let’s try the toString

method for the

BankAccount class:

BankAccount x = new

BankAccount(5000);

String s = x.toString( ); //

sets s to “BankAccount@

d246bf”

// print the name of the

class and the memory

address of the object

To work better,

overriding toString

method:

public class BankAccount

{ public String toString()

{ return “BankAccount

[balance=” + balance + “]

”; }

}

BankAccount x = new

BankAccount(5000);

String s = x.toString( );

// sets s to

“BankAccount

[balance=5000]”

Overriding the equals

Method

The equals method is

called whenever we

want to compare two

objects:

if (account1.equals

(account2)) …

// contents are the same

Compare to:

if (account1 = = account2)

…

// test two references are

the same object

public class

BankAccount

{ public boolean equals

(Object otherObj)

{ if (otherObj

instanceof

BankAccount)

{ BankAccount other =

(BankAccount)

otherObj;

return balance = =

other.balance;

}

else

return false;

}

}

Overriding the clone

method

To make a copy of an

object:

public class BankAccount

{ public Object clone( )

{ BankAccount clonedAcc

= new BankAccount

(balance);

return clonedAcc;

}

}

When we call the

method:

BankAccount acc1 = new

BankAccount(1000);

BankAccount acc2 =

(BankAccount)acc1.clone();

Compared to:

BankAccount acc1 =

new BankAccount

(1000);

BankAccount acc2 =

acc1;

Clone Mutable

Instance Variables

Consider the following

class:

public class Customer

{ private String name;

private BankAccount

account;

public Customer(String

aName)

{ name = aName;

account = new

BankAccount();

}

public String getName()

{ return name; }

public BankAccount

getAccount()

{ return account; }

getAccount method

breaks encapsulation

because anyone can

modify the object

state without going

through the public

interface:

Customer harry = new

Customer(“Harry

Handsome”);

BankAccount account =

harry.getAccount();

// anyone can

withdraw money!

account.withdraw

(100000);

So, we should clone

the object reference:

public BankAccount

getAccount()

{ return (BankAccount)

account.clone(); }

The rule of thumb is

that a class should

clone all references to

mutable objects that it

gives out.

The converse is true

as well-- a class

should clone

references that it

receives:

public Customer(String

aName, BankAccount

anAccount)

{ name = aName;

account = (BankAccount)

anAccount.clone();

}

Using Object.clone()

If we have an object

with many instance

variables, it can be

tedious to copy them

all into a new object.

The Object.clone()

simply creates a new

object whose instance

variables are copies of

the original.

public class

BankAccount

{ public Object clone()

{ // not complete

Object clonedAccount

= super.clone();

return clonedAccount;

}

}

Object.clone() checks

that the object being

cloned implements the

Cloneable interface

and do exception

handling.

public class BankAccount

implements Cloneable

{ public Object clone()

{try

{ // clones all instance

variables

Object clonedAccount =

super.clone();

return clonedAccount;

}

catch (

CloneNotSupportedEx

ception e)

{ return null; }

}

}

If an object contains a

reference to another

mutable object, then

we need to call clone

for that reference, in

order to prevent

shallow copy problem

(see Figure 11).

public class Customer

implements Cloneable

{ private String name;

private BankAcount

account;

public Object clone()

{ try

{ Object

clonedCustomer =

(Customer)super.clone

();

clonedCustomer.

account =

(BankAccount)

account.clone();

return

clonedCustomer;

}

catch (

CloneNotSupportedEx

ception e)

{ return null; }

}

}

Packages

A Java package is a

set of related classes.

Table1: Important

Packages in the Java

Library

java.lang Langauge

supoort Math

java.util Utilites

Random

java.io Input/Output

PrintStream

java.awt Abstract

Windowing Color

Toolkit

java.applet Applets

Applet

java.net Networking

Socket

java.sql Database

access ResultSet

javax.swing Swing UI

JButton

To put classes in a

package:

package

packagename;

package

com.horstmann.ccj;

import

java.io.InputStream;

import java.io.

InputStreamReader;

public class

ConsoleReader { … }

….

Importing Packages

import

com.horstmann.ccj.

ConsoleReader;