Object-Oriented Programming
Lecture 4: Interfaces & Inheritance
Dr. L H!ng Ph"#ng -- Department of Mathematics, Mechanics and Informatics, VNUH
July 2012
1
Tuesday, July 31, 12
Content
Interfaces Inheritance
Defining an interface Overriding and hiding
methods
Implementing an interface
Polymorphism
Using an interface as a type
Object as a super class
Rewriting interfaces
Final classes and methods
Abstract methods and classes
Tuesday, July 31, 12
Defining an interface
public interface GroupedInterface extends Interface1, Interface2, Interface3 {
// base of natural logarithms
double E = 2.718282;
// method signatures
void doSomething(int i, double x);
int doSomethingElse(String s);
}
If an interface is not declared public, it will be accessible only to
classes defined in the same package as the interface.
A class can extend only one other class, an interface can extend any
number of interfaces.
An interface can also contain constant declarations.
3
Tuesday, July 31, 12
Implementing an interface
public interface Relatable {
public int isLargerThan(Relatable other);
}
public class Person implements Relatable {
double weight;
public Person(double w) {
}
weight = w;
Implement the
public double getWeight() {
return weight;
required method
}
public int isLargerThan(Relatable other) {
Person person = (Person) other;
if (this.getWeight() < person.getWeight())
return -1;
else if (this.getWeight() > person.getWeight())
return 1;
else
}
return 0; Note the casting
}
4
Tuesday, July 31, 12
Implementing an interface
public class RectanglePlus implements Relatable {
int width = 0;
int height = 0;
Point origin;
public RectanglePlus(Point p, int w, int h) {
origin = p;
width = w;
height = h; Implement the
}
public int getArea() { required method
return width * height;
}
public int isLargerThan(Relatable other) {
RectanglePlus otherRect = (RectanglePlus) other;
if (this.getArea() < otherRect.getArea())
return -1;
else if (this.getArea() > otherRect.getArea())
return 1;
else
return 0;
}
}
5
Tuesday, July 31, 12
Using an interface as a type
An interface is a reference data type.
If you define a reference variable whose type is an interface, any object
you assign to it must be an instance of a class that implements the
interface.
public Object findLargest(Object object1, Object object2) {
Relatable obj1 = (Relatable)object1;
Relatable obj2 = (Relatable)object2;
if ((obj1).isLargerThan(obj2) > 0)
return object1;
else
return object2;
}
Tuesday, July 31, 12
Rewriting interfaces
Consider an interface that you have developed called DoIt:
public interface DoIt {
void doSomething(int i, double x);
int doSomethingElse(String s);
}
Suppose that at a later time, you want to add a third method to DoIt:
public interface DoIt {
void doSomething(int i, double x);
int doSomethingElse(String s);
boolean didItWork(int i, double x, String s);
}
Tuesday, July 31, 12
Rewriting interfaces
If you make this change, all classes that implement the old DoIt
interface will break because they dont implement the interface
anymore.
Programmers rely on this interface will protest loudly.
You should 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 upgrade to the new one.
Tuesday, July 31, 12
Another example of interfaces
/** Describes any class whose objects can be measured. */
public interface Measurable {
/**
* Computes the measure of the object.
*
* @return the measure
*/
double getMeasure();
}
/** Describes any class whose objects can measure other objects. */
public interface Measurer {
/**
* Computes the measure of an object.
*
* @param anObject the object to be measured
* @return the measure
*/
double measure(Object anObject);
}
9
Tuesday, July 31, 12
Content
Interfaces Inheritance
Defining an interface Overriding and hiding
methods
Implementing an interface
Polymorphism
Using an interface as a type
Object as a super class
Rewriting interfaces
Final classes and methods
Abstract methods and classes
10
Tuesday, July 31, 12
Inheritance
A class that is derived from another class is called a subclass (also a derived
class, extended class, child class).
The superclass is also called base class or parent class.
In Java, excepting Object, every class has one and only one direct
superclass (single inheritance).
A subclass inherits all the members (fields, methods, and nested classes)
from its superclass.
Constructors are not members, so they are not inherited by subclasses.
But the constructor of the superclass can be invoked from the subclass.
11
Tuesday, July 31, 12
The Java platform class hierarchy
java.lang.Object is the
base class of all Java
objects.
Classes near the bottom
of the hierarchy provide
more specialized
behavior.
12
Tuesday, July 31, 12
An example of inheritance
class MountainBike extends Bicycle {
// new fields and methods defining
// a mountain bike would go here
MountainBike has the same fields
and methods as Bicycle.
13
Tuesday, July 31, 12
class Bicycle {
The fields represent the
int cadence = 0; objects state.
int speed = 0;
int gear = 1;
void changeCadence(int newValue) {
cadence = newValue;
}
void changeGear(int newValue) {
The methods define its interaction
gear = newValue;
} with the outside world.
void speedUp(int increment) {
speed = speed + increment;
}
void applyBrakes(int decrement) {
speed = speed - decrement;
}
void printStates() {
System.out.println("cadence:" + cadence + " speed:" + speed + " gear:"
+ gear);
}
}
14
Tuesday, July 31, 12
An example of inheritance
public class MountainBike extends Bicycle {
public int seatHeight;
public MountainBike(int startHeight, int startCadence,
int startSpeed, int startGear) {
super(startCadence, startSpeed, startGear);
seatHeight = startHeight;
}
public void setHeight(int newValue) {
seatHeight = newValue;
}
}
15
Tuesday, July 31, 12
Inheritance
A subclass inherits all the public and protected members of its parent, no matter what
the package the subclass is in.
If the subclass is in the same package as its parent, it also inherits the package-private
members of the parent.
If you declare a field in the subclass with the same name as the one in the
superclass --> hide it (not recommended)
If you write a new instance method that has the same signature as the one in the
superclass --> override it.
If you write a new static method that has the same signature as the one in the
superclass --> hide it.
Use the keyword super to invoke the constructor of the superclass.
16
Tuesday, July 31, 12
Private members in a superclass
A subclass does not inherit the private member of its parent class.
However, if the superclass has public or protected methods for
accessing its private fields, they can be used to access these fields.
A nested class has access to all the private members of its enclosing
class--both fields and methods.
Therefore, a public or protected nested class inherited by a subclass
has indirect access to of the private members of the superclass.
17
Tuesday, July 31, 12
Casting objects
The object myBike is of type MountainBike:
MountainBike myBike = new MountainBike();
MountainBike is descended from Bicycle and Object:
A MountainBike is a Bicycle and is also an Object.
Casting shows the use of an object of one type in place of another type.
Object obj = new MountainBike();
Implicit casting: obj is both an Object and a MountainBike.
if (obj instanceof MountainBike) {
Explicit casting: MountainBike myBike = (MountainBike)obj;
} 18
Tuesday, July 31, 12
Overriding and hiding methods
An instance method in a subclass with the same signature and return type
as an instance method in the superclass overrides the superclass method.
This allows a class to inherit from a superclass whose behavior is
similar and then to modify behavior as needed.
Use @override annotation to instruct the compiler (optional).
If a subclass defines a class method with the same signature as a class
method in the superclass, the method in the subclass hides the one in the
superclass.
Note that the access modifier for an overriding method can allow more,
but not less, access than the overridden method.
19
Tuesday, July 31, 12
Overriding and hiding methods
public class Animal {
public static void testClassMethod() {
System.out.println("The class" + " method in Animal.");
}
public void testInstanceMethod() {
System.out.println("The instance " + " method in Animal.");
}
}
public class Cat extends Animal {
public static void testClassMethod() {
System.out.println("The class method" + " in Cat.");
}
public void testInstanceMethod() {
System.out.println("The instance method" + " in Cat.");
}
public static void main(String[] args) {
Cat myCat = new Cat();
Animal myAnimal = myCat;
Animal.testClassMethod();
myAnimal.testInstanceMethod();
} The class method in Animal.
} The instance method in Cat. 20
Tuesday, July 31, 12
Polymorphism
Subclasses of a class can define their own unique behaviors and yet
share some of the same functionality of the parent class.
Suppose that we have a base class Person and three subclasses
Vietnamese, English and French.
public class Person { class English extends Person {
public void sayHello() { @Override
System.out.print("I will say: "); public void sayHello() {
} super.sayHello();
} System.out.println("Hello!");
}
}
class Vietnamese extends Person {
@Override class French extends Person {
public void sayHello() { @Override
super.sayHello(); public void sayHello() {
System.out.println("Xin cho!"); super.sayHello();
} System.out.println("Bonjour!");
} }
} 21
Tuesday, July 31, 12
Polymorphism
public class TestPerson {
public static void main(String[] args) {
The Java virtual machine calls the
Person p0, p1, p2; appropriate method for the object
p0 = new Vietnamese();
p1 = new English();
that is referred to in each variable.
p2 = new French();
p0.sayHello(); This is virtual method invocation, an
p1.sayHello();
p2.sayHello(); important aspect of polymorphism.
}
}
I will say: Xin cho!
I will say: Hello!
I will say: Bonjour!
22
Tuesday, July 31, 12
Object as a superclass
java.lang.Object is the root class of all the classes.
Some important methods of Object that we may want to inherit:
protected Object clone() throws CloneNotSupportedException;
public boolean equals(Object obj);
protected void finalize() throws Throwable;
public int hashCode();
public String toString();
23
Tuesday, July 31, 12
Writing final classes and methods
You can declare some or all of a classs methods final.
This indicates that the method cannot be overridden by subclasses.
You make a method final if it has an implementation that should not be changed and
is critical to the consistent state of the object.
class ChessAlgorithm {
enum ChessPlayer {WHITE, BLACK}
//...
final ChessPlayer getFirstPlayer() {
return ChessPlayer.WHITE;
}
//...
}
Methods called from constructors should be declared final.
Final classes cannot be subclassed.
24
Tuesday, July 31, 12
Abstract methods and classes
An abstract class is a class declared abstract. It may or may not include
abstract methods.
Abstract method: abstract void moveTo(double deltaX, double deltaY);
If a class includes an abstract method, that class must be abstract:
public abstract class GraphicObject {
// declare fields
// declare non-abstract methods
abstract void draw();
}
If a subclass of an abstract class does not provide implementations for all
abstract methods in its parent class, it has to also be declared abstract.
25
Tuesday, July 31, 12
Abstract class versus interfaces
Unlike interfaces, abstract classes can contain fields that are not static
and final and they can contain implemented methods.
Interfaces: full abstraction
Abstract class: partial abstraction
Abstract classes are most commonly subclassed to share pieces of
implementation.
26
Tuesday, July 31, 12
An abstract class example
In an object-oriented drawing application, you can draw many different
graphic objects.
They all have certain states (position, orientation, line color, fill color...) and
behaviors (moveTo, rotate, resize, draw...).
Some of these states and behaviors are the same for all objects: position,
fill color, moveTo.
Some require different implementations: resize, draw.
27
Tuesday, July 31, 12
An abstract class example
abstract class GraphicObject { class Circle extends GraphicObject {
int x, y; void draw() {
// ... //...
void moveTo(int newX, int newY) { }
//... void resize() {
} //...
abstract void draw(); }
abstract void resize(); }
}
class Rectangle extends GraphicObject {
void draw() {
//...
}
void resize() {
//...
}
}
28
Tuesday, July 31, 12
Reference
The Java Tutorial
Trail: Learning the Java language
http://docs.oracle.com/javase/tutorial/java/TOC.html
29
Tuesday, July 31, 12
Exercise
Exercise 1. Consider the Card, Deck and DisplayDeck classes that you
wrote in a previous exercise (previous lectures).
What Object methods should these classes override?
Override these methods with suitable implementation.
Exercise 2. See the file 04-OOP-Exercises.pdf.
30
Tuesday, July 31, 12
