Java 中的某些方法为什么要求传入一个 Class 对象

  在 Java 中，某些方法要求传入一个 Class 对象，这能保证该方法能返回一个正确的类型的对象，从而免除返回后的强制类型转换。比如 Spring 容器中的 getBean 方法，此方法有两个常用的重载：

Object getBean(String name) throws BeansException;

<T> T getBean(String name, Class<T> requiredType) throws BeansException;

  这两个方法中，其中有一个方法多了一个类型为 Class<T> 的参数，那么，多提供这个 Class<T> 参数的作用是什么呢？

  熟悉 Spring 的读者应该很清楚，使用有 Class<T> 参数的 getBean 方法，可以免除之后的强制类型转换。因为 Java 支持基类引用指向子类对象，但基类引用只能调用基类方法，这一点与此基类引用指向的是本基类对象还是子类对象无关。也就是说，基类引用无法调用子类名称特有的方法（编译会不通过），而很多方法都会返回 Object 类型，这意味着强制转换经常是必要的。

  那么，为什么使用有 Class<T> 参数的方法可以做到这一点呢？或者说，如何通过传递 Class<T> 参数来使该方法能返回想要的类型呢？

  这可以通过设计这样的一个函数来实现：

public static <T> T convertType(Object objToBeConverted, Class<T> convertedType) {
    return (T) objToBeConverted;
}

  这样一来，强制类型转换 (SomeClass)someObject 即可由调用此函数 convertType(someObject, SomeClass.class) 来替代了（设 SomeClass 为某类名。someObject 为 Object 引用类型，其指向 SomeClass 对象或其子类对象）。

  不过，要注意的是，上述自定义函数 convertType 的形参 Class<T> convertedType 中的 T，是基于静态类型推断得出的。如果传入给形参 convertedType 的实参是动态生成的 Class 对象，则此处的 T 可能不是预想的值。例如：

public class Test {
    private static <T> T convertType(Object objToBeConverted, Class<T> convertedType) {
        System.out.println("函数 convertedType 被调用。其中，形参 convertedType：" + convertedType);
        System.out.println("");
        return (T) objToBeConverted;
    }

    public void fun(Test test) {
        System.out.println("Test 的函数 fun(Test test) 被调用。其中，形参 test：" + test.getClass());
        System.out.println("");
    }

    public static void main(String[] args) {
        System.out.println("");
        
        Test testExtends1 = new TestExtends();
        // 函数 convertedType 被调用。其中，形参 convertedType：class TestExtends
        var result1 = convertType(testExtends1, testExtends1.getClass());
        // TestExtends 的函数 fun(Test testExtends) 被调用。其中，形参 testExtends：class TestExtends
        result1.fun(result1);

        TestExtends testExtends2 = new TestExtends();
        // 函数 convertedType 被调用。其中，形参 convertedType：class TestExtends
        var result2 = convertType(testExtends2, testExtends2.getClass());
        // TestExtends 的函数 fun(TestExtends testExtends) 被调用。其中，形参 testExtends：class TestExtends
        result2.fun(result2);

        TestExtends testExtends3 = new TestExtends();
        // 函数 convertedType 被调用。其中，形参 convertedType：class TestExtends
        var result3 = convertType(testExtends3, TestExtends.class);
        // TestExtends 的函数 fun(TestExtends testExtends) 被调用。其中，形参 testExtends：class TestExtends
        result3.fun(result3);
    }
}

class TestExtends extends Test {
    @Override
    public void fun(Test testExtends) {
        System.out.println("TestExtends 的函数 fun(Test testExtends) 被调用。其中，形参 testExtends：" + testExtends.getClass());
        System.out.println("");
    }

    public void fun(TestExtends testExtends) {
        System.out.println("TestExtends 的函数 fun(TestExtends testExtends) 被调用。其中，形参 testExtends：" + testExtends.getClass());
        System.out.println("");
    }
}

  可以看出，上述代码中的对象 testExtends1 与 testExtends2 属于同一类型 TestExtends，但由于它们分别被不同类型的引用所接收，通过各自的 getClass() 来动态生成类型，所以导致即便是函数 convertedType 的形参 convertedType 是正确的值，但函数 convertedType 中的 T 却不正确。静态推断的结果是将 T 推断为各自对象引用的类型，而不是各自对象自身真正的类型。因此，当调用函数 convertedType 时，应该像上面的 testExtends3 一样，使用明确的类型 XXX.class 作为实参，而不是使用 Object 对象的方法 getClass() 。

  因此，对于本文开头提及的方法，如果传入类型为 Class<T> 的参数，该方法就能保证返回值类型为指定的类型。