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

骑猪看日落 2021-09-25 04:36 224阅读 0赞

### 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` 作为实参，而不是使用 `getClass()`** 。

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