Polymorphism
> Click or hit Control-Enter to run Example.main above
PSA: Don’t Enter Early
Please be polite to the class that meets before us and don’t enter the classroom until they are done.
Next Few Classes
We’re a bit ahead!
-
Today: polymorphism and inheritance review
-
Friday: objects review session, including examples from this week’s homework problems
-
Next Monday: more about polymorphism
-
Next Wednesday: no class
Hierarchical Thinking
Why organize objects into a hierarchy?
-
It can be a natural expression of real-world taxonomies
-
It allows us to organize and reuse code between multiple classes
The Tree Of (Java) Life
In Java, each class has a single parent, meaning that classes are organized into a tree.
If we follow each node to its parent, we eventually get to the top, or root…
The Root Object: Object
public class Dog { }
// is equivalent to
public class Dog extends Object { }If a Java class does not explicitly extend another class, it implicitly
extends Object.
Inherited from Object
public class Dog {
private String name;
Dog(String setName) {
this.name = setName;
}
}
public class Example {
public static void main(String[] unused) {
Dog chuchu = new Dog("Chuchu");
System.out.println(chuchu.toString());
}
}All Java objects inherit a small number of important methods from Object.
As a result, all Java objects implement these methods!
Methods Inherited from Object
For our purposes, the following methods inherited from Object are important:
-
String toString(): return aStringrepresenting the instance. Frequently used for debugging. -
boolean equals(Object other): return abooleanindicating whether this object is the same as another object -
int hashCode(): return anintuniquely representing an object’s contents. We’ll talk more about hashing later—it’s incredibly important and useful.
Method Overriding
public class Dog {
private String name;
Dog(String setName) {
this.name = setName;
}
public String toString() {
return this.name;
}
}
public class Example {
public static void main(String[] unused) {
Dog chuchu = new Dog("Chuchu");
System.out.println(chuchu.toString());
}
}The default Object methods are rarely useful.
So classes usually override them and provide their own.
Hierarchical Name and Method Resolution
The Java type hierarchy is used when resolving the names of variables and methods:
-
Does the class have a variable or method with the given name? If so, use it.
-
If not, search the parent class—but limited by
publicandprotected -
Continue up the tree until the name is found or the search fails
> Click or hit Control-Enter to run Example.main above
super Constructor
public class Pet {
protected String type;
Pet(String setType) {
this.type = setType;
}
}
public class Dog extends Pet {
private String breed;
Dog(String setBreed) {
super("Dog");
this.breed = setBreed;
}
}Java classes can access their parent’s constructor using the super keyword.
This must be the first thing done in a child constructor.
> Click or hit Control-Enter to run Example.main above
Polymorphism
Polymorphism: the provision of a single interface to entities of different types.
We’ll discuss interfaces in more detail when we talk about about packages. For now, let’s identify two kinds of Java polymorphism using examples.
Subtype Polymorphism
public class Pet {
public void printMe() {
System.out.println("I'm a pet");
}
}
public class Dog extends Pet {
public void printMe() {
System.out.println("I'm a dog");
}
}In Java, every object is really an instance of at least two types:
-
Each
Petis also anObject -
Each
Dogis also aPetand also anObject
Object Conversion: Upcasting
public class Pet { }
public class Dog extends Pet {
public String toString() {
return "Dog";
}
}
public class Example {
public static void main(String[] unused) {
Dog chuchu = new Dog();
Pet xyz = new Pet();
Example.printAnything(chuchu);
Example.printAnything(xyz);
}
public static void printAnything(Object toPrint) {
System.out.println(toPrint.toString());
}
}Java will upcast object types automatically.
> Click or hit Control-Enter to run Example.main above
But Instances Retain Their Types
public class Pet { }
public class Dog extends Pet {
public String toString() {
return "Still a Dog";
}
}
public class Example {
public static void main(String[] unused) {
Dog chuchu = new Dog();
Object chuchuAsObject = chuchu;
System.out.println(chuchuAsObject);
Pet chuchuAsPet = chuchu;
System.out.println(chuchuAsPet);
}
}> Click or hit Control-Enter to run Example.main above
Object Conversion: Downcasting
public class Pet { }
public class Dog extends Pet {
public String toString() {
return "Still a Dog";
}
}
public class Example {
public static void main(String[] unused) {
Object chuchu = new Dog();
Example.printAnything(chuchu);
Pet chuchuAsPet = (Pet) chuchu; // chuchu is a Pet, so this works
Example.printAnything(chuchuAsPet);
}
}We can also cast instances down but only if the instance is actually the appropriate subtype.
Java checks the cast at runtime to make sure that it is appropriate.
> Click or hit Control-Enter to run Example.main above
Type Testing: instanceof
public class Pet { }
public class Dog extends Pet { }
public class Cat extends Pet { }
public class Example {
public static void main(String[] unused) {
Pet chuchu = new Dog();
Pet xyz = new Cat();
System.out.println(chuchu instanceof Dog); // Prints true
System.out.println(chuchu instanceof Pet); // Prints true
System.out.println(chuchu instanceof Cat); // Prints false
}
}The Java instanceof operator allows you to test whether an object is an
instance of or a descendant of a particular class.
> Click or hit Control-Enter to run Example.main above
Liskov Substitution Principle
Substitutability is a principle in object-oriented programming stating that, in a computer program, if S is a subtype of T, then objects of type T may be replaced with objects of type S (i.e. an object of type T may be substituted with any object of a subtype S) without altering any of the desirable properties of T (correctness, task performed, etc.).
Barbara Liskov, Turing Award Winner
Barbara Liskov was one of the first women in the US to earn a doctorate in computer science. She won the Turing Award, the highest honor in computer science, in 2008.
She’s given a bunch of great talks that you can find on YouTube, like this one.
Substitutability in Practice
public class Pet { }
public class Dog extends Pet {
public String toString() {
return "Dog";
}
}
public class Example {
public static void main(String[] unused) {
Dog chuchu = new Dog();
Pet xyz = new Pet();
Example.printAnything(chuchu);
Example.printAnything(xyz);
}
public static void printAnything(Object toPrint) {
System.out.println(toPrint.toString());
}
}Since everything is an Object, any Java object inherits all of the desirable
properties of Object: like toString.
Subtype Polymorphism
We can always use toString, but every class can implement it
differently.
Same Names, Different Behavior
Where else have we seen this before?
> Click or hit Control-Enter to run the code above
Polymorphism
Polymorphism: the provision of a single interface to entities of different types.
-
Subtype polymorphism: a single method can act on all descendants of a given class
-
Method overloading: a method can behave differently depending on its arguments
-
Generic types (discussed later)
Object Modeling
We frequently use Java objects to model real objects or entities.
Objects allow us to design software that deals with things in realistic and natural ways.
Let’s Model Something
> Click or hit Control-Enter to run Example.main above
Announcements
-
MP2 is out and due in less than two weeks. Get started!
-
We will reopen this week’s lab exercise tomorrow and let you enjoy it over the weekend.
-
I have office hours from 1–3PM today in Siebel 2227. Please stop by!
-
We will not have a lecture next Wednesday.
-
We have a anonymous feedback form to the course website. Use it to give us feedback!