Inheritance and Polymorphism

Chapter 11
Spring 2007
CS 101
Aaron Bloomfield

1
This section is not required material!!!!
 A note about inheritance…
 It’s not normally covered in 101
 It will be gone over in more detail in CS 201

 Ask questions if you are confused about inheritance

 You aren’t the only one!

2
Motivation
 Consider a transportation computer game
 Different types of vehicles:
 Planes
 Jets, helicopters, space shuttle
 Automobiles
 Cars, trucks, motorcycles
 Trains
 Diesel, electric, monorail
 Ships
 …

 Let’s assume a class is written for each type of vehicle

3
More on classes vs. objects

4
Motivation
 Sample code for the types of planes:
 fly()
 takeOff()
 land()
 setAltitude()
 setPitch()
 Note that a lot of this code is common to all types of planes
 They have a lot in common!
 It would be a waste to have to write separate fly()
methods for each plane type
 What if you then have to change one – you would then
have to change dozens of methods

5
Motivation
 Indeed, all vehicles will have similar methods:
 move()
 getLocation()
 setSpeed()
 isBroken()

 Again, a lot of this code is common to all types of vehicles

 It would be a waste to have to write separate move() methods
for each vehicle type
 What if you then have to change one – you would then have
to change dozens of methods

 What we want is a means to specify one move() method, and have

each vehicle type inherit that code
 Then, if we have to change it, we only have to change one copy
6
 Motivation

Provides: Provides:
fly() move()
takeOff() getLocation()
land() setSpeed()
setAltitude() Vehicle
isBroken()
setPitch()

Planes Trains Automobiles

Helicopter Jet Space shuttle Car Truck Motorcycle

Diesel Electric Monorail

Provides: Provides:
derail() oilChange()
getStation() isInTraffic()
7
Motivation
 What we will do is create a “parent” class and a “child” class

 The “child” class (or subclass) will inherit the methods (etc.)
from the “parent” class (or superclass)

 Note that some classes (such as Train) are both subclasses

and superclasses

8
Inheritance code
class Vehicle {
...
}

class Train extends Vehicles {

...
}

class Monorail extends Train {

...
}

9
About extends
 If class A extends class B
 Then class A is the subclass of B
 Class B is the superclass of class A
 A “is a” B
 A has (almost) all the methods and variables that B has

 If class Train extends class Vehicle

 Then class Train is the subclass of Vehicle
 Class Vehicle is the superclass of class Train
 Train “is a” Vehicle
 Train has (almost) all the methods and variables that
Vehicle has

10
Object-oriented terminology
 In object-oriented programming languages, a class created
by extending another class is called a subclass
 The class used for the basis is called the superclass
 Alternative terminology
 The superclass is also referred to as the base class
 The subclass is also referred to as the derived class

Monorail Train Vehicle

11
 10 dimensions
 Disclaimer: it doesn’t have much scientific
validity
 http://tenthdimension.com/

12
Another example
 Consider shapes in a graphics program
 Shape class
 Circle class
 Cube class
 Dodecahedron class

14
Inheritance
 Organizes objects in a top-down fashion from most general to
least general

 Inheritance defines a “is-a” relationship

 A mountain bike “is a” kind of bicycle
 A SUV “is a” kind of automobile
 A border collie “is a” kind of dog
 A laptop “is a” kind of computer

15
Packages
 Allow definitions to be collected together into a single entity—
a package

 The classes in our game could be added to a package

 Classes and names in the same package are stored in the

same folder

 Classes in a package go into their own “namespace” and

therefore the names in a particular package do not conflict
with other names in other packages

 For example, a package called OtherGame might have a

different definition of Map 16
Controlling access
 Class access rights

Member this Subclass Package General

Restriction
public    
protected    

default    

private    

17
Java’s Mother-of-all-objects—Class Object

Circle Shape Object

Class Class Superclass of all

representing representing Java objects.
a circle any shape

18
Thus, everything extends Object
 Either directly or indirectly

 So what does that give us?

 Object contains the following methods:

 clone()
 equals()
 toString()
 and others…

 Thus, every class has those methods

19
More about clone()
 It’s protected in class Object
 Which means that a Circle class also has a protected
version
 Recall that protected means that code outside the Circle
class can NOT call it

 If we wanted a clone() method, we would declare it as such:

 public Object clone() { … }

 Otherwise, we would get the following error message:

 Method clone() has protected visibility in class Cirlce

20
A note about equals()
 Why does the equals() method always have to have the
following prototype:
 boolean equals(Object obj)

 Many other class in the Java SDK require the use of equals()
 Such as the Vector class

 Those classes need to know how the equals() method will

work in order for them to work properly
 Thus, it must have the same prototype

 Same for toString()

 This method allows Java to “print” out an object
21
Overriding
 Consider the following code:

class Foo { // automatically extends Object

public String toString () {
return “Foo”;
}
}
...
Foo f = new Foo();
System.out.println (f);

 Now there are two toString() method defined

 One inherited from class Object
 One defined in class Foo
 And they both have the same prototype!

 Which one does Java call?

22
Overriding
 Java will call the most specific overriden method it can
 toString() in Foo is more specific than toString() in Object

 Consider our transportation hierarchy:

 Assume each class has its own toString() method
 Car extends Automobile extends Vehicle (extends Object)
 Assume each defines a toString() methods

 The toString() method in Vehicle is more specific (to vehicles) than

the one in Object
 The toString() method in Automobiles is more specific than the ones
in Vehicle or Object
 The toString() method in Car is more specific than the ones in
Automobile, Vehicle, or Object

 Thus, for a Car object, the Car toString() will be called

 There are ways to call the other toString() methods
 This has to be specifically requested 23
Overriding
 This is called overriding, because the toString() in Foo
“overrides” the toString() in Object

 Note that the prototype must be EXACTLY the same

 With overloading, the parameter list must be DIFFERENT

 Overriding only works with inheritance

 In particular, you can only override a method already
defined in a parent (or grandparent, etc.) class

24