Subtyping Rules David Evans cs205: engineering software BlackBear university of virginia fall 2006 Subtyping Rules Killer Bear Climber KillingBear BlackBear GrizzlyBear David Evans www.cs.virginia.edu/cs205

Recap If B is a subtype of A, everywhere an A is expected, a B can be used To implement a subtype, it is often useful to use the implementation of its supertype class B extends A B is a subtype of A B inherits from A class C implements F C is a subtype of F

Behavioral Subtyping? Killer Bear What’s the difference between a Black Bear and a Grizzly Bear? Climber KillingBear When you climb up the tree, the Black Bear climbs up after you. The Grizzly Bear knocks down the tree. (Which is the behavioral subtype?) BlackBear GrizzlyBear

Subtyping Example public class Bear { public Bear () { } abstract public boolean chaseHuman (Human h); public void eatHuman (Human h) { if (chaseHuman (h)) say (“Yum Yum!”); } public void say (String s) { System.err.println (“Bear says: ” + s); public class BlackBear extends Bear { public boolean chaseHuman (Human h) { // follow h and climb the tree return true; } public void say (String s) { System.err.println (“BlackBear says: ” + s); BlackBear b = new BlackBear (); b.eatHuman (h);

Overloading and Overriding Overriding: replacing a supertype’s method in a subtype Dynamic dispatch finds method of actual type Overloading: providing two methods with the same name but different parameter types Statically select most specific matching method of apparent type

Overloading Example public class Overloaded extends Object { public int tryMe (Object o) { return 17; } public int tryMe (String s) { return 23; public boolean equals (String s) { return true; public boolean equals (Object) is inherited from Object

Overloading 17 23 true false static public void main (String args[]) { public class Overloaded { public int tryMe (Object o) { return 17; } public int tryMe (String s) { return 23; public boolean equals (String s) { return true; Overloading static public void main (String args[]) { Overloaded over = new Overloaded (); System.err.println (over.tryMe (over)); System.err.println (over.tryMe (new String ("test"))); Object obj = new String ("test"); System.err.println (over.tryMe (obj)); System.err.println (over.equals (new String ("test"))); System.err.println (over.equals (obj)); Object obj2 = over; System.err.println (obj2.equals (new String ("test"))); } 17 23 true false

Overkill Overloading and overriding together can be overwhelming! Avoid overloading whenever possible: names are cheap and plentiful One place you can’t easily avoid it: constructors (they all have to have the same name, but can use static methods to create new objects)

How do we know if saying B is a subtype of A is safe?

Substitution Principle If B is a subtype of A, everywhere the code expects an A, a B can be used instead For a function f (A), if f satisfies its specification when passed an object whose actual type is type A, f also satisfies its specification when passed an object whose actual type is B.

What needs to be true? public int f (a A, x X) { return a.m (x); } For a function f (a A), if f satisfies its specification when passed an object whose actual type is type A, f also satisfies its specification when passed an object whose actual type is B. public int f (a A, x X) { return a.m (x); }

Subtype Condition 1: Signature Rule We can use a subtype method where a supertype methods is expected: Subtype must implement all of the supertype methods Argument types must not be more restrictive Result type must be at least as restrictive Subtype method must not throw exceptions that are not subtypes of exceptions thrown by supertype

Signature Rule class A { public RA m (PA p) ; } class B extends A { public RB m (PB p) ; } RB must be a subtype of RA: RB <= RA PB must be a supertype of PA: PB >= PA covariant for results, contravariant for parameters

Signature Examples public class Object { public boolean equals (Object o) ; } public class String extends Object { } public boolean equals (Object o) ;

Signature Examples public class CellSet { // A set of Cell’s. public Cell choose () throws NoSuchElementException ; } public class ConwayCellSet extends CellSet { // A set of ConwayCell (<= Cell) objects. public ConwayCell choose () } public Cell choose () ; Return type must be a subtype of Cell.

Java’s Rule Java compiler is stricter than this: doesn’t allow any variation in types (“novariant”): Overriding method must have same return and parameter types Overriding method must throw the same or fewer exceptions than supertype method.

What needs to be true? public int f (a A, x X) { For a function f (a A), if f satisfies its specification when passed an object whose actual type is type A, f also satisfies its specification when passed an object whose actual type is B. public int f (a A, x X) { // REQUIRES: a is initialized // EFFECTS: returns a.value * x.value return a.m (x); }

Substitution Principle Continues in class 15...