Polymorphism
> Click or hit Control-Enter to run Example.main above
Review: static and Encapsulation
Please make sure you understand static.
-
Don’t just add it or remove it from methods or variables until the test cases work
Review: HW25
Complete the implementation of a class called LastTen.
Your class should implement two public methods as described below:
-
void add(int newValue): add a new integer to the values that we are remembering -
int[] getLastTen(): return the last ten values that were added using add, in any order. If fewer than ten values were added, you should return zeros in their place.
Your class should also provide a constructor that takes no arguments. It should not expose any of its state publicly.
> Click or hit Control-Enter to run Example.main above
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
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)
Announcements
-
The MP3 early deadline is Monday. Please get started if you haven’t already.
-
I have office hours today at 10AM in my office (Siebel 2227).
-
We will not have a lecture next Wednesday—I may record a video lecture instead.