基于返回类型的Java泛型转换？

Question

The following code is from an Android library called ButterKnife. I'm figuring out how it works.

@SuppressWarnings("unchecked") // That's the point.
  public <T> T castParam(Object value, String from, int fromPosition, String to, int toPosition) {
    try {
      return (T) value;
    } catch (ClassCastException e) {
      throw new IllegalStateException("Parameter #"
          + (fromPosition + 1)
          + " of method '"
          + from
          + "' was of the wrong type for parameter #"
          + (toPosition + 1)
          + " of method '"
          + to
          + "'. See cause for more info.", e);
    }
  }

I tried to recreate the behaviour of this function:

  @SuppressWarnings("unchecked")
    public static <T> T cast(Object o){
        try {
            return (T) o;
        } catch (ClassCastException e){
            throw new AssertionError("Error");
        }
    }

And usage:

Object o = new String("test");
Double d = cast(o);

But the exception is not never caught, it gets thrown at the line when the method is called. Why is that?

Also, how does this work exactly? How does the method know what to cast to?

Answer 1

Generics types are checked at compile time only, due to type erasure. This is done because there was no way to introduce generics in the runtime in Java 5 without breaking backwards compatibility and forcing to recompile all the already existing libraries.

Long history short, when you define a "generic" class or method, the actual code is compiled as Object instead of the type you are binding the method. All the checks of types are done at compile time.

So, your method code is not actually doing a cast in the return statement, since it is assigning something (a String ) to an Object return value. The actual ClassCastException is returned by the calling line because it is the place when the reference variable is actually typed.

Answer 2

As SJuan67 explained, you cannot really use casts with generic types as Java compiler will

Replace all type parameters in generic types with their bounds or Object if the type parameters are unbounded. The produced bytecode, therefore, contains only ordinary classes, interfaces, and methods.

More info on all generics restrictions here .

So ButterKnife code will look like this:

  public Object castParam(Object paramObject, String paramString1, int paramInt1, String paramString2, int paramInt2)
  {
    return paramObject;
  }

So to your questions:

Q: But the exception is not never caught, it gets thrown at the line when the method is called. Why is that?

A: Well its not even in the bytecode.

Q: Also, how does this work exactly? How does the method know what to cast to?

A: It doesn't. At least not like you think it will. In practice it will throw ClassCastException not IllegalStateException or AssertionError as you observed. You can even try it with ButterKnife sample app and Bind a known TextView to CheckBox:

@Bind(R.id.title) CheckBox title;

Q: How does the library work then?

A: Well IllegalStateException is just never called and you have ClassCastException. Why it is like that I an not really sure. However as ButterKnife generates code this could be intended to prevent from compile errors.

for example:

public interface Some {
}

public static void weWantSome(Some d) {
}

public static void test() {
    String o = "test";
    weWantSome((Some)o); //<-- compile error
    weWantSome(Main.<Some>cast(o)); //<-- runtime error
} 

Which is why in the previous example code compiles but does not run.