How do these three parameterized variables differ?

Question

Given AGenericClass declared as below:

public class AGenericClass<T> {
  T subject;
  public void setSubject(T subject) {
    this.subject = subject;
  }
}

What are the differences between variables a, b, and c?

AGenericClass<String> a = new AGenericClass<>();
AGenericClass<?> b = new AGenericClass<String>();
AGenericClass c = new AGenericClass<String>();

a.setSubject("L"); // OK.

b.setSubject("M"); // Error: setSubject(capture<?>) cannot be
                   // applied to (java.lang.String)

c.setSubject("N"); // Warning: Unchecked call to 'setSubject(T)'
                   // as a member of raw type 'AGenericClass'

a b and c all are declared without complaint from the IDE, but they all behave differently when setSubject is called.

score 3 · Accepted Answer · edited May 23 '17 at 12:07

The differences between the three largely have to do with the checks that you get at compile time. Given that generics were meant to guard the user from an unsafe cast at runtime, the critical and major differences between them are rooted there.

AGenericClass<String> declares an instance of a generic class specifically of type String. Any operation done with this generic that requires a generic parameter will have that parameter bound to String, and will enforce type checking and type safety at compile time.

That is to say, if you have AGenericClass<String> a = new AGenericClass<>(); and you try to call a.setSubject(3), Java will not allow the application to compile since the types don't match up.

AGenericClass<?> declares an instance of a generic class with unknown types. Formally, ? is a wildcard in which it could be any type, which is fine if you want to retrieve elements from it, but not fine if you want to add elements from it.

The reason? AGenericClass<?> is actually AGenericClass<? extends Object>, and that's important because of the in and out principle. Generally (although this isn't a strict guarantee), anything generic with extends implies a read-only operation.

As I said before, it's fine to read from, since you're guaranteed a class that is at most an Object, but you can't write to it since you don't know, nor can you guarantee, what kind of object you're adding to it from any given call.

AGenericClass without the type declarations is a raw type. You can read more about them here, but know that they exist for legacy compatibility reasons. If your code makes use of raw types, you lose the compile time checks and your code may wind up throwing a ClassCastException during runtime, which is far more difficult to debug, diagnose, and resolve.

score 2 · Answer 2 · answered Mar 17 '16 at 06:23

AGenericClass<String> a = new AGenericClass<>();

So called "Diamond" generic instantiating. When you set empty <> on constructor of generic type, compiler will try determine type from context. In example case compiler will use <String> because a declared with <String>.

AGenericClass<?> b = new AGenericClass<String>();

This named "Unbounded Wildcards". b will be created as generic of unknown type. When you are trying to use setSubject(), compiler can't check the type of argument. This why you get exception. To resolve this issue, you can create helper method with defined generic type.

AGenericClass c = new AGenericClass<String>();

In this case c declared as "Raw type". c will be created as generic with <Object> parameter. Because you can assign String to Object, method setSubject() will work with a String. Actually, it will work with any type, that inherited from Object, and potentially this could be cause of error. And compiler warns you about it.

score 1 · Answer 3 · edited Mar 17 '16 at 05:55

AGenericClass<String> a = new AGenericClass<>();

Indicates this is a AGenericClass of String type and will accept String in the parameter in place of type parameter T. So it doesn't complain when you called a.setSubject("L");.

AGenericClass<?> b = new AGenericClass<String>();

? indicates it is unbounded wildcard, means a

type is not specified or unknown

With this, all that is guarantees is return type would be Object, if you have a method like public T getSubject(). You can assign to a variable of type Object or pass it as a parameter where the type Object is expected. Won't be able to perform set operation. extends and super are two keywords that you can use along with ? to set the lower/upper bound that you may want to explore further.

AGenericClass c = new AGenericClass<String>();

The Warning: Unchecked call to 'setSubject(T)'.. is indicating that this call is being made as raw type, so it won't complain even if you call setSubject(new Integer(1)) i.e., it doesn't perform any check for type safety. But subsequently when you try to get this subject and cast it to String you would encounter ClassCastException as you have ignored the compiler warning and we don't get type safety benefit provided by generics.

How do these three parameterized variables differ?

3 Answers3