Covariant Return

[Krep Lock]

Some of the nuances of polymorphism remain foggy to me. Today it's covariant return types. I read a description of this feature and was surprised there is even a name for it - but apparently this behavior was illegal in previous versions. Or, maybe I'm missing something.

My understanding: covariant return types mean you can change the return type of an overridden method, as long as the new return type is derivative of the original return type. Is that it, or am I missing something about this feature? Here's my example:

//  Covariant.java
 
class Animal
{
String type;
 
Animal() { type = "beast"; }
public String toString() { return(type); }
}
 
class Cat extends Animal
{
String species;
 
Cat() { species = "tiger"; }
public String toString() { return(type + " " + species); }
}
 
class GameWarden
{
public static Animal getAnimal()
{
return(new Animal());
}
}
 
class CatWrangler extends GameWarden
{
public static Cat getAnimal()
{
return(new Cat());
}
}
 
public class Covariant
{
public static void main(String[] args)
{
Animal aMonkey = GameWarden.getAnimal();
Cat aTiger = CatWrangler.getAnimal();
System.out.println(aTiger);
}
}

[ February 03, 2008: Message edited by: Krep Lock ]

[Ilja Preuss]

No, you aren't missing anything. And yes, it was introduced with Java 5.

Covariant return types are possible because they don't violate Liskov's Substitution Principle.

Interestingly, the JVM always supported them, it was only the language specification (and the compiler, consequently) that needed to be changed for this feature.