Java 中，类、类对象、泛型之间的转换

秒速五厘米 2021-09-25 04:30 889阅读 0赞

### Java 中，类、类对象、泛型之间的转换 ###

*  R 为非泛型
 *   *  获得类
     *   *  通过类型名来获得类
         *  通过对象来获得类
         *  通过类名字符串来获得类
     *  通过类来获得类名字符串
     *  通过类来获得对象
     *   *  使用 R 的无参数构造器来创建对象
         *  使用 R 的有参数构造器来创建对象
 *  T 为泛型
 *   *  通过泛参来得到 Class 对象
     *  通过泛参来创建实例对象
     *  通过泛型非空引用来得到 Class 对象
     *  通过 Class 对象来得到泛参
     *  通过 Class 对象来创建实例对象
     *   *  使用 T 的无参数构造器来创建对象
         *  使用 T 的有参数构造器来创建对象

# R 为非泛型 #

这里说的类是指某个对象所属的类所对应的类 `Class<?>` 的对象。

## 获得类 ##

### 通过类型名来获得类 ###

已有某类的一个类型名 R（R不是泛型形参，而是某个具体的类型名），来得到该类名字符串所对应的类 `Class<R>` 的对象：

// “通过类型名来获得类”
    Class<R> targetClass = R.Class; // 这里 R 不是泛型形参，而是某个具体的类型名

### 通过对象来获得类 ###

已有一个类型名为 R（R不是泛型形参，而是某个具体的类型名）的对象，来得到该对象所属的类所对应的类 `Class<R>` 的对象：

// rObject 为已有对象，函数 getRObject 代表一个返回类 R 对象的函数
    R rObject = getRObject();
    
    // “通过类对象来获得类”
    Class<R> targetClass = rObject.getClass();

### 通过类名字符串来获得类 ###

已有类 R 的类名字符串，来得到该类名字符串所对应的类 `Class<R>` 的对象：

// className为已有类名字符串，函数 getClassRName 代表一个返回一个类名字符串的函数
    String className = getClassRName();
    
    // “通过类名字符串来获得类”
    Class<R> targetClass = Class.forName(className);

## 通过类来获得类名字符串 ##

已有某类所对应的 `Class<R>` 对象，来得到该类类名：

// classR 为已有 Class 对象，函数 getClassR 代表一个返回 R 类对象的函数
    Class<R> classR = getClassR();
    
    // “通过类来获得类名字符串”
    String className = classR.getName();

## 通过类来获得对象 ##

已有一个 `Class<R>` 对象，来得到一个类型为R的对象：

### 使用 R 的无参数构造器来创建对象 ###

// classR 为已有 Class 对象，函数 getClassR 代表一个返回 R 类对象的函数
    Class<R> classR = getClassR();
    
    // “通过类来获得类对象”：使用 R 的无参数构造器来创建对象
    Object targetObj = classR.getConstructor().newInstance();

### 使用 R 的有参数构造器来创建对象 ###

设 R 的某个构造器的参数分别为类A、类B的对象。类 A、类 B 均有公有的无参数构造器，且 A、B 均不是泛型（变量）：

// classR 为已有 Class 对象，函数 getClassR 代表一个返回 R 类对象的函数
    Class<R> classR = getClassR();
    
    // “通过类来获得类对象”：使用 R 的有参数构造器来创建对象
    Object targetObj = classR
            .getConstructor(A.class, B.class)
            .newInstance(aObject, bObject);

--------------------

# T 为泛型 #

## 通过泛参来得到 Class 对象 ##

已有泛型变量 T，来得到对应的 `Class<T>` 对象：  
  **没有这种办法**。必须通过外部主动提供泛型变量 T 的已实例化的对象，才能得到对应的 `Class<T>` 对象。因为类型擦除等原因，以下这几种都是错误的：

*  错误示例1：

// 设 T 为已被“赋值”的泛型变量
    Class<T> targetClass = T.class; // 因为类型擦除，所以 T.class 会退化为 Object.class

*  错误示例2：

// 设 T 为已被“赋值”的泛型变量
    Class<T> targetClass; // 使用这种方法创建的只是一个空引用

## 通过泛参来创建实例对象 ##

已有泛型变量 T，来得到对应的类型为 T 的对象：  
  **没有这种办法**。必须通过泛型变量 T 对象的 `Class<T>` 对象，才能得到对应的类型为 T 的对象。因为类型擦除等原因，以下这几种都是错误的：

*  错误示例1：

// 设 T 为已被“赋值”的泛型变量
    T targetObject = new T(...); // 因为类型擦除，所以 new T(...) 会退化为 new Object(...)

*  错误示例2：

// 设 T 为已被“赋值”的泛型变量
    T targetObject; // 使用这种方法创建的只是一个空引用

## 通过泛型非空引用来得到 Class 对象 ##

已有泛型变量 T 的非空引用，来得到对应的 `Class<T>` 对象：

// T 为泛型类中设置的泛型变量，函数 getRObject 代表一个返回类 R 对象的函数
    T genericObject = getRObject();
    
    // “通过泛型非空引用来得到 Class 对象”
    Class<T> targetClass = (Class<T>) genericObject.getClass();

## 通过 Class 对象来得到泛参 ##

已有 `Class<T>` 对象，来取出其中的泛型形参 T：（不过，由于 Java 中的类型擦除，一般得到泛型变量没什么用。）

// “通过 Class 对象来得到泛型变量”
    // classT 为已有 Class 对象，函数 getClassT 代表一个返回 Class 对象的函数
    Class<T> classT = getClassT(); // 现在，T 即为需要的泛型变量

## 通过 Class 对象来创建实例对象 ##

已有 `Class<T>` 对象，来得到对应的类型为 T 的对象：

### 使用 T 的无参数构造器来创建对象 ###

// classT 为已有 Class 对象，函数 getClassT 代表一个返回 Class 对象的函数
    Class<T> classT = getClassT(); 
    
    // “通过类来获得类对象”：使用 T 的无参数构造器来创建对象
    Object targetObj = someClass.getConstructor().newInstance();

### 使用 T 的有参数构造器来创建对象 ###

设 T 的某个构造器的参数分别为类 A、类 B 的对象。类 A、类 B 均有公有的无参数构造器，且 A、B 均不是泛型（变量）：

// classT 为已有 Class 对象，函数 getClassT 代表一个返回 Class 对象的函数
    Class<T> classT = getClassT(); 
    // aObject 为已有对象，函数 getFirstParameter 代表一个返回 A 对象的函数
    A aObject = getFirstParameter();
    // bObject 为已有对象，函数 getSecondParameter 代表一个返回 B 对象的函数
    B bObject = getSecondParameter();
    
    // “通过类来获得类对象”：使用 T 的有参数构造器来创建对象
    Object targetObj = classT
            .getConstructor(A.class, B.class)
            .newInstance(aObject, bObject);