当类型参数用于强制转换时，Java 类型擦除如何工作？

Question

I know generally unbound type parameters are substituted with Object in compile time. But how does this piece of code work?

<T> void call(List<T> list, Object o) {
    fun((T) o);
}

Will it be compiled to

void call(List list, Object o) {
    fun((Object) o);
}

Which seems like a wrong case because o should be cast to the same type as the elements in list?

Answer 1

Because of type erasure even if your type is A , it will be treated as Object in your example as you guessed. which means if you passed your second elem other than A , it will actually be casted to Object .

Example,

import java.util.ArrayList;
import java.util.List;

public class TypeErasure {

    static <A> void call(List<A> list, Object elem) {
        A o1 = (A) elem;
        System.out.println(o1);
    }

    static void callV2(List list, Object elem) {
        System.out.println(elem);
    }

    //bounded type
    static <A extends Number> void callV3(List<A> list, Object elem) {
        A o1 = (A) elem;
        System.out.println(o1);
    }

    public static void main(String[] args) {
        call(new ArrayList<Integer>(), "trying to cast string to Integer");
        callV2(new ArrayList<Integer>(), "trying to cast string to Integer");

        //will be casted to Number
        callV3(new ArrayList<Integer>(), 1);
        callV3(new ArrayList<Double>(), 1.5);
        callV3(new ArrayList<Long>(), 1L);

        // following will fail at runtime with ClassCastException
        /* Exception in thread "main" java.lang.ClassCastException: 
           class java.lang.String cannot be cast to class java.lang.Number 
          (java.lang.String and java.lang.Number are in 
           module java.base of loader 'bootstrap')
        */
        callV3(new ArrayList<Integer>(), "trying to cast string to Integer");
    }

}

Answer 2

No, because type information is available in java only in runtime, hence it won't compile to anything more specific than Object . Other case would be, if type parameter T was bound, for example:

 <T extends Number> void call(List<T> list, Object o) {
     fun((T) o);
 }

Then the compiler doesn't know the exact type at compile time, but it does know it's a subtype of Number , so if method fun consumed Number as parameter, it would compile as opposed to the first example.

You can find more info here .

Answer 3

Will it be compiled to

No, no cast will be inserted if the bound is Object , because a cast to Object always succeeds.

If the type variable were bounded, eg T extends Number , then a checkcast instruction would be inserted to ensure that o is a Number , equivalent to (Number) o .

You may notice that the compiler generates a unchecked warning on that line. An unchecked warning means that the compiler is unable to insert a bytecode to ensure that o is an instance of T , specifically.

---

It's also worth pointing out that the type variable is redundant. You can use the following, and it will be equivalent:

void call(List<?> list, Object o) {
    fun(o);
}

The cast is unnecessary, since fun must be able to accept any Object anyway.