CHAPTER 9

INHERITANCE
AND
INTERFACES

Copyright © 2013 by John Wiley & Sons. All rights reserved. Slides by Donald W. Smith Final Draft
TechNeTrain.com 10/29/2011
 Comparing Interfaces and Inheritance
 Here is a different interface: Named
public interface Named
{
String getName();
}
 A class can implement more than one interface:
public class Country implements Measurable, Named
 A class can only extend (inherit from) a single superclass.
 An interface specifies the behavior that an implementing
class should supply - no implementation.
 A superclass provides some implementation that a subclass
inherits.
 Develop interfaces when you have code that processes
objects of different classes in a common way.
 Casting from Interfaces to Classes
 Method to return the object with the largest
measure:
public static Measurable larger(Measurable obj1,
Measurable obj)
{
if (obj1.getMeasure() > obj2.getMeasure())
{
return obj1;
}
else
{
return obj2;
}
}

 Returns the object with the larger measure, as

a Measurable reference.
Country uruguay = new Country("Uruguay", 176220);
Country thailand = new Country("Thailand", 513120);
Measurable max = larger(uruguay, thailand);
 Casting from Interfaces to Classes
 You know that max refers to a Country object,
but the compiler does not.
 Solution: cast
Country maxCountry = (Country) max;
String name = maxCountry.getName();
 You need a cast to convert from an interface type
to a class type.
 If you are wrong and max doesn't refer to a
Country object, the program throws an exception
at runtime.
 If a Person object is actually a Superhero, you
need a cast before you can apply any Superhero
methods.
 The Comparable Interface
 Comparable interface is in the standard Java library.
 Comparable interface has a single method:
public interface Comparable
{
int compareTo(Object otherObject);
}
 The call to the method:
a.compareTo(b)
 The compareTo method returns:
 a negative number if a should come before b,
 zero if a and b are the same
 a positive number if b should come before a.
 Implement the Comparable interface so that objects of
your class can be compared, for example, in a sort
method.
 The Comparable Interface
 BankAccount class' implementation of
Comparable:
public class BankAccount implements Comparable
{
. . .
public int compareTo(Object otherObject)
{
BankAccount other = (BankAccount) otherObject;
if (balance < other.balance) { return -1; }
if (balance > other.balance) { return 1; }
return 0;
}
. . .
}

 compareTo method has a parameter of reference

type Object
 To get a BankAccount reference:
BankAccount other = (BankAccount) otherObject;
 The Comparable Interface
 Because the BankAccount class implements the
Comparable interface, you can sort an array of bank
accounts with the Arrays.sort method:
BankAccount[] accounts = new BankAccount[3];
accounts[0] = new BankAccount(10000);
accounts[1] = new BankAccount(0);
accounts[2] = new BankAccount(2000);
Arrays.sort(accounts);

 Now the accounts array is sorted by increasing balance.

 The compareTo method checks whether another object
is larger or smaller.
 Self Check
Write a method max that finds the larger of any
two Comparable objects.

Answer:
public static Comparable max(Comparable a,
Comparable b)
{
if (a.compareTo(b) > 0) { return a; }
else { return b; }
}
 Inner Classes
 Trivial class can be declared inside a method:
public class MeasurerTester
{
public static void main(String[] args)
{
class AreaMeasurer implements Measurer
{
. . .
}
. . .
Measurer areaMeas = new AreaMeasurer();
double averageArea = Data.average(rects,
areaMeas);
. . .
}
}
 Inner Classes
 You can declare inner class inside an enclosing
class, but outside its methods.
 It is available to all methods of enclosing class:
public class MeasurerTester
{
class AreaMeasurer implements Measurer
{
. . .
}
public static void main(String[] args)
{
Measurer areaMeas = new AreaMeasurer();
double averageArea = Data.average(rects, areaMeas);
. . .
}
}
 Inner Classes
 Compiler turns an inner class into a regular
class file with a strange name:
MeasurerTester$1AreaMeasurer.class
 Inner classes are commonly used for utility
classes that should not be visible elsewhere in
a program.
 Implementing Interfaces
 An interface can be implemented by multiple classes.
 Each implementing class can provide their own unique versions of the
method definitions.

interface I1 {
void m1() ;
}

class C1 implements I1 {
public void m1() { System.out.println(“Implementation in C1”); }
}

class C2 implements I1 {
public void m1() { System.out.println(“Implementation in C2”); }
}
 Interfaces
 A class can implement multiple
interfaces

 The interfaces are listed in the

implements clause

 The class must implement all methods in

all interfaces listed in the header
class ManyThings implements interface1, interface2
{
// all methods of both interfaces
}
 Implementing More Than One
Interface
interface I1 {
void m1();
}
interface I2 {
void m2() ; C must implement all methods in I1 and I2.
void m3() ;
}
class C implements I1, I2 {
public void m1() { System.out.println(“C-m1”); }
public void m2() { System.out.println(“C-m2”); }
public void m3() { System.out.println(“C-m3”); }
}
 Resolving Name Conflicts Among
Interfaces
 Since a class may implement more than one interface, the names in
those interfaces may collide.
 To solve name collisions, Java use a simple mechanism.
 Two methods that have the same name will be treated as follows in
Java:
 If they are different signature, they are
considered to be overloaded.
 If they have the same signature and the same
return type, they are considered to be the same
method and they collapse into one.
 If they have the same signature and the
different return types, a compilation error will
occur.
 Resolving Name Conflicts Among
Interfaces
interface I1 {
void m1();
void m2();
void m3();
}
interface I2 {
void m1(int a); There will be a compilation error for m3.
void m2();
int m3();
}
class C implements I1, I2 {
public void m1() { … } // implementation of m1 in I1
public void m1(int x) { … } // implementation of m1 in I2
public void m2() { … } // implementation of m2 in I1 and I2
}
 Inheritance Relation Among
Interfaces
 Same as classes, interfaces can hold
inheritance relation among them

interface I2 extends I1 { … }

 Now, I2 contains all abstract methods of I1

plus its own abstract methods.
 The classes implementing I2 must
implement all methods in I1 and I2.
 Interfaces as Data Types
 Interfaces (same as classes) can be used as data types.
 Different from classes: We cannot create an instance of an interface.

interface I1 { … }
class C1 implements I1 { … }
class C2 extends C1 { … }

// a variable can be declared as type I1

I1 x;

 A variable declared as I1, can store objects of C1 and C2.

 More later…
 The Iterator Interface
 As we discussed in Chapter 5, an iterator is an
object that provides a means of processing a
collection of objects one at a time
 An iterator is created formally by implementing the
Iterator interface, which contains three methods
 The hasNext method returns a boolean result –
true if there are items left to process
 The next method returns the next object in the
iteration
 The remove method removes the object most
recently returned by the next method
 The Iterator Interface
 By implementing the Iterator interface, a
class formally establishes that objects of
that type are iterators

 The programmer must decide how best to

implement the iterator functions

 Once established, the for-each version of

the for loop can be used to process the
items in the iterator
 Interfaces
 You could write a class that implements
certain methods (such as compareTo)
without formally implementing the interface
(Comparable)

 However, formally establishing the

relationship between a class and an
interface allows Java to deal with an object
in certain ways

 Interfaces are a key aspect of object-

oriented design in Java
 When to use Abstract Methods &
Abstract Class?
 Abstract methods are usually declared where
two or more subclasses are expected to fulfill a
similar role in different ways through different
implementations
 These subclasses extend the same Abstract class
and provide different implementations for the
abstract methods
 Use abstract classes to define broad types of
behaviors at the top of an object-oriented
programming class hierarchy, and use its
subclasses to provide implementation details
of the abstract class.
 Why do we use Interfaces?
Reason #1
 To reveal an object's programming interface
(functionality of the object) without revealing
its implementation
 This is the concept of encapsulation
 The implementation can change without
affecting the caller of the interface
 The caller does not need the implementation at
the compile time
• It needs only the interface at the compile time
• During runtime, actual object instance is associated with the interface
type
 Why do we use Interfaces?
Reason #2
 To have unrelated classes implement
similar methods (behaviors)
 One class is not a sub-class of another
 Example:
 Class Line and class MyInteger
• They are not related through inheritance
• You want both to implement comparison methods
– checkIsGreater(Object x, Object y)
– checkIsLess(Object x, Object y)
– checkIsEqual(Object x, Object y)

 Define Comparison interface which has the

three abstract methods above
 Why do we use Interfaces?
Reason #3
 To model multiple inheritance
 A class can implement multiple interfaces while
it can extend only one class
 Interface vs. Abstract Class
 All methods of an Interface are abstract
methods while some methods of an Abstract
class are abstract methods
 Abstract methods of abstract class have abstract
modifier
 An interface can only define constants while
abstract class can have fields
 Interfaces have no direct inherited relationship
with any particular class, they are defined
independently
 Interfaces themselves have inheritance relationship
among themselves
 Problem of Rewriting an Existing
Interface
 Consider an interface that you have
developed called DoIt:
public interface DoIt {
If you make this change, all
void doSomething(int i, double x);
int doSomethingElse(String s);
} classes that implement the

old DoIt interface
Suppose that, at a later time, you want to will break
add a third method because theysodon't
to DoIt, that the
interface now becomes: implement all methods of
public interface DoIt {the interface anymore
void doSomething(int i, double x);
int doSomethingElse(String s);
boolean didItWork(int i, double x, String s);
}
 Solution of Rewriting an Existing
Interface
 Create more interfaces later
 For example, you could create a DoItPlus
interface that extends DoIt:
public interface DoItPlus extends DoIt {
boolean didItWork(int i, double x, String s);
}
 Now users of your code can choose to
continue to use the old interface or to
upgrade to the new interface
 When to use an Abstract Class over
Interface?
 For non-abstract methods, you want to use
them when you want to provide common
implementation code for all sub-classes
 Reducing the duplication
 For abstract methods, the motivation is the
same with the ones in the interface – to
impose a common behavior for all sub-classes
without dictating how to implement it
 Remember a concrete can extend only one
super class whether that super class is in the
form of concrete class or abstract class