Java中泛型T和Class<T>的理解

最新推荐文章于 2025-03-04 11:33:42 发布

samir_liu

最新推荐文章于 2025-03-04 11:33:42 发布

阅读量7.6k

点赞数 10

分类专栏： JAVA基础文章标签： java 泛型

本文链接：https://blog.csdn.net/m0_37683758/article/details/86738543

版权

JAVA基础专栏收录该内容

12 篇文章

订阅专栏

Class类

Class类的实例表示Java应用运行时的类（class ans enum）或接口（interface and annotation）（每个Java类运行时都在JVM里表现为一个Class对象，可通过类名.class，类型.getClass()，Class.forName("类名")等方法获取Class对象）。数组同样也被映射为为Class对象的一个类，所有具有相同元素类型和维数的数组都共享该Class对象。基本类型boolean，byte，char，short，int，long，float，double和关键字void同样表现为Class对象。

T、Class<T>和Class<?>

单独的T代表一个类型，而Class<T>和Class<?>代表这个类型所对应的类

Class<T>在实例化时，T要替换成具体类

Class<?>是个通配泛型，?可以代表任何类型

<? extends T>受限通配，表示T的一个未知子类。

<? super T>下限通配，表示T的一个未知父类。

public T find(Class<T> clazz, int id);

根据类来反射生成一个实例，而单独用T没法做到。

Object类中包含一个方法名叫getClass，利用这个方法就可以获得一个实例的类型类。类型类指的是代表一个类型的类，因为一切皆是对象，类型也不例外，在Java使用类型类来表示一个类型。所有的类型类都是Class类的实例。getClass()会看到返回Class<?>。

JDK中，普通的Class.newInstance()方法的定义返回Object，要将该返回类型强制转换为另一种类型;

但是使用泛型的Class<T>，Class.newInstance()方法具有一个特定的返回类型;

public class Main2 {

    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        System.out.println("1-----------");
        Dog dog1 = creatNew1(Dog.class);
        System.out.println(dog1.name + " is " + dog1.type+ "\n");

        System.out.println("2-----------");
        Animal ani1 = creatNew2(Cat.class);
        Cat cat1 = (Cat) ani1;
        System.out.println(cat1.name + " is " + cat1.type + "\n");

        System.out.println("3-----------");
        Object obj = creatNew3(Dog.class);
        Dog dog2 = (Dog) obj;
        System.out.println(dog1.name + " is " + dog2.type + "\n");

        System.out.println("4-----------");
        Object obj2 = creatNew4(Cat.class);
        Cat cat2 = (Cat) obj2;
        System.out.println(cat2.name + " is " + cat2.type + "\n");

        System.out.println("5-----------");
        Object obj3 = creatNew5(new Cat());
        Cat cat3 = (Cat) obj3;
        System.out.println(cat3.name + " is " + cat3.type + "\n");
    }

    /**
     * 此方法是一个非泛型类中的泛型方法，参数为Class<T>类型，可以传入任何类，但是Class<T>将参数在函数内部的类型固定为 T类，使用clazz.newInstance(),返回的类型也为固定的 T 类型。
     * 如: 传入Dog.class, 函数中的 T 固定为Dog.class,函数返回的是Dog类型，不需要强制转换为Dog类型
     * （当然，函数返回类型也可以是Object类型，但是没必要）
     */
    public static <T> T creatNew1(Class<T> clazz) throws IllegalAccessException, InstantiationException {
        System.out.println(clazz);//打印具体传入的类型。
        return clazz.newInstance();
    }

    /**
     * 此方法参数是Class<? extends Animal>，只能传入Animal及其子类的类型，函数返回类型只能声明为Animal或Object类型，
     * 如：传入Cat.class，函数返回一个Animal的子类对象，需将此子类对象强制转换为具体的子类(即Cat类)。
     */
    public static Animal creatNew2(Class<? extends Animal> clazz) throws IllegalAccessException, InstantiationException {
        System.out.println(clazz);//打印具体传入的类型。
        return clazz.newInstance();
    }

    /**
     * 此方法参数是Class，可传入任何类，其返回只能声明为Object类对象。
     * 如：传入Dog.class, 返回的是Object类型的对象，需强制转换为Dog类型的对象。
     */
    public static Object creatNew3(Class clazz) throws IllegalAccessException, InstantiationException {
        System.out.println(clazz);//打印具体传入的类型。
        return clazz.newInstance();
    }

    /**
     * 传入参数Class<?> 和 上一个方法传入 Class 的区别还不是很清楚，其返回只能声明为Object类对象。
     * 如：Cat.class, 返回的是Object类型的对象，需强制转换为Cat类型的对象。
     */
    public static Object creatNew4(Class<?> clazz) throws IllegalAccessException, InstantiationException {
        System.out.println(clazz);//打印具体传入的类型。
        return clazz.newInstance();
    }

    /**
     * 传入Object类型的对象，返回也声明为Object类型。
     */
    public static Object creatNew5(Object object) {
        System.out.println(object.getClass());//打印具体传入的类型。
        return object;
    }
}

abstract class Animal {
    public String type = "type = animal ";
}

class Dog extends Animal {
    public String name = "name = gou";
}

class Cat extends Animal {
    public String name = "name = mao";
}

/**
 * 这些方法，传的参数声明不同，其返回的声明也必然要随之不同。
 */