CODEWITHSUNDEEP
javagenerics
Steve Kuo
Steve Kuo

Reputation: 63094

Non-generic reference to generic class results in non-generic return types

I have a legacy class that the class itself is not a generic but one of its methods return type uses generics:

public class Thing {
    public Collection<String> getStuff() { ... }
}

getStuff() uses generics to return a collection of strings. Therefore I can iterate over getStuff() and there's no need to cast the elements to a String:

Thing t = new Thing();
for (String s: t.getStuff())  // valid
{ ... }

However, if I change Thing itself to be a generic but keep everything else the same:

public class Thing<T> {
    public Collection<String> getStuff() { ... }
}

and then keep using the non-generic reference to Thing, getStuff() no longer returns Collection<String> and instead returns a non-typed Collection. Thus the client code does not compile:

Thing t = new Thing();
for (String s: t.getStuff())  // compiler complains that Object can't be cast to String
{ ... }

Why is this? What are the workarounds?

My guess is that by using a non-generic reference to a generic class, Java turns off all generics for the entire class. This is pain, because now I've broken my client code by making Thing a generic.

Edit: I'm making Thing generic for another method which is not listed in the above example code. My question is educational as to why the above cannot be done.

Upvotes: 8

Views: 5522

Answers (3)

Ebrahim Byagowi
Ebrahim Byagowi

Reputation: 11228

I think this is totally normal. In my opinion using Thing t = new Thing(); for generic enabled class is totally a mistake. When compiler see a generic class used as a class without type parameter, it think it must erase all generic types from that class. This is how you can compile old codes without use of generics in new java compilers and compiler let that old codes use generic enabled classes (e.g. java.util.ArrayList) without any problem. (and this is how java not need separated System.Collection.Generic.List and System.Collection.List like C#). You can run Thing t = new Thing(); with adding a simple type parameter on it, Thing<Object> t = new Thing<Object>();, only thing java compiler needs is making sure that you are using java generic consciously. I never can blame Java for its great backward compatibility.

I know I am a bit late :D

Upvotes: 0

cletus
cletus

Reputation: 625087

Ok, take two, I misunderstood your question.

When you delcare Thing (this is called a raw type) instead of Thing<?> (parameterized type) the Java compiler strips out all generic arguments, even thogh (as in your case) the generic type of the method has nothing to do with the generic type of the class.

From the (excellent) Java Generics FAQ:

Can I use a raw type like any other type?

Methods or constructors of a raw type have the signature that they would have after type erasure.

This seemingly inocuous and unobtrusive sentence describes the behaviour in question. You're using Thing as a raw type so the return type is Collection (not Collection<String>) since this is the type after type erasure.

Confused? Not surprising. Just look at the size of that FAQ. There's probably about three people on earth who nderstand the full implications of Java Generics. Just consider my favourite declaration from the JDK:

Enum<T extends Enum<T>>

(Theres an explanation of that in the FAQ too).

Upvotes: 10

Ryan Ahearn
Ryan Ahearn

Reputation: 7934

It is failing because of erasure. You can read more about it in these Java Tutorials

Upvotes: 0

Related Questions