Book Chapter : Inheritance

Reference types must be superclass of object types

Consider the following valid program:

class Person {}
class Student extends Person {}
public class MyProgram {
	public static void main(String[] args) {
		Person x = new Student();
	}
}

Person x = new Student() is valid, even though the left hand type and right hand type are not equal. We call the left hand type the reference type, and the right hand type the object type. The left hand type refers to what type "x" is. The right hand type refers to the new Person() in memory that x points to ("references").

Any reference can point to a subclass of the reference type, so it is valid for x to point to student. Note that it is not valid for a Student reference to point to a new Person(). This is because not every Student "is a" Person.

1st Rule of Polymorphism: Behavior depends on Object (Right)

Polymorphism tell us the behavior of code when the left and right hand types are not equivalent. In Java (as well as most other languages), the behavior of code depends on the object that a reference is pointing to. Here is an example:

class Animal {
	void makeSound() {
		System.out.println("Grrr");
	}
}
class Cat extends Animal {
	void makeSound() {
		System.out.println("Meow");
	}
}
public class MyProgram {
	public static void main(String[] args) {
		Animal a = new Animal();
		a.makeSound(); //Grr, as expected
		Cat c = new Cat(); 
		c.makeSound(); //Meow, as expected

		Animal x = new Cat();  
		x.makeSound(); //Meow, due to polymorphism
		x = new Animal();
		x.makeSound(); //Grr, since x points to a new Animal()
	}
}

2nd Rule of Polymorphism: Compilation depends on the reference (left)

Consider the cat and dog classes below:

class Animal {}
class Cat extends Animal {
	void makeSound() {
		System.out.println("Meow");
	}
}
class Dog extends Animal {
	void makeSound() {
		System.out.println("Woof");
	}
}
public class MyProgram {
	public static void main(String[] args) {
		Animal c = new Cat();
		Animal d = new Dog();
		

		// c.makeSound(); // <-- try uncommenting
		// d.makeSound(); // <-- try uncommenting
		Cat catReference = (Cat)c;
		Dog dogReference = (Dog)d;
		catReference.makeSound();  //Ok
		dogReference.makeSound();  //Ok
	}
}

The two commented lines, c.makeSound and d.makeSound(), do not compile. Java will not even allow you to run the code, since the Animal class does not have a makeSound method. Even though c and d are actually a Cat and a Dog, and even though those objects have a makeSound method, compilation depends on the reference type.

Polymorphic use of Collections

Given multiple objects that share a supertype, it is possible to put them in one Collection that is generic on the supertype. Note that this is true in general: any method that takes a type automatically accepts objects that are subtypes.

import java.util.*;
class Animal {
	void makeSound() { System.out.println("Grrr"); }
}
class Cat extends Animal {
	void makeSound() { System.out.println("Meow"); }
}
class Dog extends Animal {
	void makeSound() { System.out.println("Woof"); }
}
public class MyProgram {
	public static void main(String[] args) {
		ArrayList<Animal> x = new ArrayList<Animal>();
		x.add(new Cat()); //valid
		x.add(new Dog()); //valid
		for(Animal a : x) a.makeSound(); //first meow then woof
	}
}