泛型和演员表

Question

我尝试编写一个带有参数名称并可以返回给定对象的相应参数的类。目前，我的班级是这样的：

public class ParamValue<T> {

    private String paramName;

    @SuppressWarnings("unchecked")
    public T getValue(Object obj) throws Exception {

        Class<?> c = obj.getClass();
        Field param = c.getDeclaredField(paramName);
        boolean isAccessible = param.isAccessible();
        param.setAccessible(true);
        Object value = param.get(obj);
        param.setAccessible(isAccessible);
        return (T) value;
    }

    // get set ...
}

现在，假设我们有一个带有简单 Long 参数的对象：

public class ExampleClass {

    private Long value;

    // get set ...
}

我们可以这样做来取回长值：

    ExampleClass ec = new ExampleClass();
    ec.setValue(12L);

    ParamValue<Long> pvString = new ParamValue<>();
    pvString.setParamName("value");

    // print 12
    System.out.println(pvString.getValue(ec));

现在，例如，如果我将“ParamValue”声明为一个点，它仍然有效：

    ExampleClass ec = new ExampleClass();
    ec.setValue(12L);

    ParamValue<Point> pvPoint = new ParamValue<>();
    pvPoint.setParamName("value");

    // print 12
    System.out.println(pvPoint.getValue(ec));

但是，由于 Point 无法转换为 Long，我预计会出现一些异常，例如 ClassCastException。

我知道 java 编译器在编译时会进行一些类型擦除，但我认为编译器会自动尝试转换为 Point 并失败，以输出“pvPoint.getValue(ec)”

有人可以解释一下这是如何工作的吗？

谢谢

Answer 1

ClassCastException 是一个 RuntimeException，这意味着它只会在运行时抛出，而不是在编译时抛出。由于您的值引用 Object value = param.get(obj); 是 Object 类型，因此应该允许您转换为类型，因为所有类都扩展 Object。您的 getValue 方法接受任何 Object 作为参数，因此在编译时，任何类都将被接受，无论您声明的参数化类型如何。

如果你想要类型安全，你可以将方法的参数声明为<? extends T>，然后只允许 T 和扩展它的类进行方法调用。

你也可以这样修改方法：

    public <T> T getValue(Class<T> returnType, Object obj) throws Exception {
        Class<?> c = obj.getClass();
        Field param = c.getDeclaredField(paramName);
        boolean isAccessible = param.isAccessible();
        param.setAccessible(true);
        Object value = param.get(obj);
        param.setAccessible(isAccessible);
        return returnType.cast(value);
}

在这种情况下，无需参数化您的类。您甚至可以将上述方法的 return 语句修改为如下内容：

     if (returnType.isInstance(value)) {
        return returnType.cast(value);
    } else {
        // could be replaced with a return null
        throw new ClassCastException("Exception message");          
    }

Answer 2

演员(T) 在运行时不做任何事情。它只会让编译器平静下来。

方法PrintStream.println 有多个重载，其中一个接受Object 参数。因此，您的代码中不会执行任何类型转换。

在这些情况下，您会看到 ClassCastException：

1. 将值存储在所需类型的变量中：

   final Point value = pvPoint.getValue(ec); // CCE
   System.out.println(value);
   

2. 为ParamValue 提供一个Class<T> 实例以进行运行时检查：

   public class ParamValue<T> {
       private final Class<T> clazz;
   
       public ParamValue(Class<T> clazz) {
           this.clazz = clazz;
       }
   
       public T getValue(Object obj) throws Exception {
           Class<?> c = obj.getClass();
           Field param = c.getDeclaredField(paramName);
           boolean isAccessible = param.isAccessible();
           param.setAccessible(true);
           Object value = param.get(obj);
           param.setAccessible(isAccessible);
           return clazz.cast(value); // instead of (T) value
       }
   
       // get set ...
   }
   

   然后：

   ParamValue<Point> pvPoint = new ParamValue<>(Point.class);
   pvPoint.setParamName("value");
   System.out.println(pvPoint.getValue(ec)); // CCE
   

Answer 3

您正在禁止编译器警告您正在执行未经检查的强制转换，因此编译器不会捕获它。并且在运行时，类型信息不可用。

如果您希望您的代码实际抛出 ClassCastException，您可以添加一个存储实际目标类的字段。这也使得删除@SuppressWarnings 注释成为可能。生成的类将如下所示：

class ParamValue<T> {

    private final Class<T> clazz;
    private final String paramName;

    ParamValue(Class<T> clazz, String paramName)
    {
        this.clazz = clazz;
        this.paramName = paramName;
    }

    public T getValue(Object obj) throws Exception {

        Class<?> c = obj.getClass();
        Field param = c.getDeclaredField(paramName);
        boolean isAccessible = param.isAccessible();
        param.setAccessible(true);
        Object value = param.get(obj);
        param.setAccessible(isAccessible);
        return clazz.cast(value);
    }
}

并且可以这样调用：

    ExampleClass ec = new ExampleClass();
    ec.setValue(12L);

    ParamValue<Point> pvPoint = new ParamValue<>(Point.class, "value");

    // print 12
    System.out.println(pvPoint.getValue(ec));

Answer 4

我发现了一个奇特的东西，以防有人进来。 如果我像他一样扩展“ParamValue”类：

public class ParamPoint extends ParamValue<Point> {
}

类型擦除仅部分应用，不会抛出异常，但仍然可以像这样测试类型：

ParamValue<Point> pvPoint = new ParamPoint();

ParameterizedType superclassType = (ParameterizedType) pvPoint.getClass().getGenericSuperclass();
Type paramType = superclassType.getActualTypeArguments()[0];

// print true
System.out.println(paramType.equals(Point.class));

希望这对某人有所帮助。