1. Inheritance and Polymorphism
Chapter 9
Fall 2006
CS 101
Aaron Bloomfield

2. 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!

3. 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

4. More on classes vs. objects

5. 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

6. 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

7. Motivation Provides: Provides: move() fly() getLocation() takeOff()
setSpeed()
isBroken()
Provides:
fly()
takeOff()
land()
setAltitude()
setPitch()
Provides:
oilChange()
isInTraffic()
Provides:
derail()
getStation()

8. 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

9. Inheritance code class Vehicle { ... } class Train extends Vehicles {
class Monorail extends Train {

10. 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

11. 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

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

13. 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

14. Inheritance and Battleship
We could have defined a Player class
And have the Human and AI classes be subclasses
We want the Human and AI interfaces to be the same!
This is one way to do this

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 Restriction this
Subclass
Package
General
public ü
protected
default
private

17. Java’s Mother-of-all-objects—Class Object
Class Object provides basic versions of several methods. In particular, it has methods toString(), equals(), and clone(). It also has methods finalize(), getClass(), hashCode(), notify(), notifyAll(), and wait(). These are all inherited by the subclasses of Object.

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. 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

20. 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?

21. 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

22. 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