CIS 26 - Polymorphism

CIS 26
Object-Oriented Programming
Polymorphism

Consequenceas of Polymorphism

Some Preliminaries

Subtypes
- Type T1 is a subtype of T2 if every value of T1 is also a legitimate value of T2.
  - Class extension (inheritance) reflects a subtype relationship
    - The subclass is a subtype of the superclass
Methods Overriding
- Introducing a method into the subclass with the exact same signature and return type as a method in the superclass
- Note this is NOT the same as overloading

Polymorphic assignment

The type of the variable on the right-hand-side must be a subtype of the type of the variable on the left-hand-side
- This is checked at compile-time in Java
- Assigning up the hierarchy (upcasting) is thus always legal
```
Super super1;
Sub sub1;
...
super1 = sub1;
			
```
- This rule also explains why assigning down the hierarchy (downcasting) requires an explicit cast
```
sub1 = super1;
			
```
  super1 is not a subtype of sub1
```
sub1 = (Sub)super1;
			
```
  casting the right-hand-side now makes it a subtype (in fact the same type) as the left-hand side.
  - Of course, the cast may fail at runtime
```
super1 = new Super();
sub1 = (Sub)super1;
			
```

Why upcast?

Passing subtype to method expecting supertype
- The collections all expect Obects
Assigning to an array of the supertype
- Basically an array is a collection too\

Why downcast?

Assigning from a method that returns a supertype

Obects are extracted from the collections

Polymorphic method invocation

Binding of the invocation of an overridden method to the actual method body (i.e., implementation) is done at runtime
- It's based on the type of the type of the object (a runtime binding) and not the type of the receiver variable (compile time binding)
```
Object obj = new Counter();		// upcast
String s = obj.toString();			// toString in class Counter is invoked	
				
```
- If the method is not in the class of the object, we proceed up the hierarchy
The method must be known to the receiver class or a compiler error will result
- Thus
```
Object obj = new Counter();		// upcast
obj.increment()						// generates a compiler error	
				
```
- This is both for efficiency as well as type safety

Putting it All into Perspective

class MyApplet extends Applet {
	...
}

Browser knows about Applet
- Browser (actually a plug-in) is Java aware
- Not MyApplet
  - You just coded it today, browser's been around much longer
How does the broswer work with MyApplet?

browser creates a MyApplet object and assigned it to an Applet object

	Applet app = Applet.load("MyApplet.class"); // rhs returns an object 
						// of type MyApplet

upcast, perfectly legal
The 'magic' is how the object is created from the '.class' file, nothing else

Then the browser invokes init

app.init();

The (static) type of app is ???
The (dynamic) type of the object app references is ???

And voila, control is passed to MyApplet!!