Java泛型-阿里云开发者社区

泛型

泛型就是指在类定义时不会设置类中的属性或方法参数的具体类型，而是在类使用时（创建对象）再进行类型的定义。会在编译期检查类型是否错误

类型安全

消除强制类型转换

泛型类

语法：

class 类名称 <泛型标识,泛型标识,……>{
  private 泛型标识 变量名;
  ……
}

常用的泛型标识：T、E、K、V

使用语法：

类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

Java1.7以后，后面的<>中的具体的数据类型可以省略不写

类名<具体的数据类型> 对象名 = new 类名<>();

MainClass类

package itiheima_09;
//泛型类
public class MainClass<T> {
    //定义成员变量，T：是由外部使用类指定
    private T key;
    //get、set方法
    public T getKey() {
        return key;
    }
    public void setKey(T key) {
        this.key = key;
    }
    //构造方法
    public MainClass(T key) {
        this.key = key;
    }
    public MainClass() {
    }
    //toString方法
    @Override
    public String toString() {
        return "MainClass{" +
                "key=" + key +
                '}';
    }
}

MainDemo类

package itiheima_09;
public class MainDemo {
    public static void main(String[] args) {
        MainClass<String> stringMainDemo = new MainClass<>("hello");
        String key1 = stringMainDemo.getKey();
        System.out.println(key1);    //hello
        MainClass<Integer> intMainDemo = new MainClass<>(100);
        int key2 = intMainDemo.getKey();    //包装类类型装换为基本数据类型：拆箱
        System.out.println(key2);   //100
        //泛型类在创建对象的时候，没有指定类型，将按照Object类型操作
        MainClass mainClass = new MainClass(100);
        Object key3 = mainClass.getKey();
        System.out.println(key3);   //100
        //泛型类不支持基本数据类型，只支持包装类类型
        //MainClass<int> objectMainClass = new MainClass<int>();
        //同一泛型类，根据不同的数据类型创建的对象，本质是同一类型
        System.out.println(stringMainDemo.getClass());  //class itiheima_09.MainClass
        System.out.println(intMainDemo.getClass());     //class itiheima_09.MainClass
        System.out.println(stringMainDemo.getClass() == intMainDemo.getClass());    //true
    }
}

总结

泛型类，如果没有指定具体的数据类型，此时，操作类型是Object

泛型的类型参数只能是包装类类型，不能是具体数据类型

泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同类型

案例

抽奖实现

ProductGetter

package itiheima_10;
import java.util.ArrayList;
import java.util.Random;
public class ProductGetter<T> {
    Random random = new Random();
    //奖品
    private T product;
    //奖品池
    ArrayList<T> list = new ArrayList<>();
    //添加奖品
    public void addProduct(T t){
        list.add(t);
    }
    //抽奖
    public T getProduct() {
        product = list.get(random.nextInt(list.size()));
        return product;
    }
}

MainClass

package itiheima_10;
public class MainClass {
    public static void main(String[] args) {
        //创建抽奖类对象，指定数据类型
        ProductGetter<String> stringProductGetter = new ProductGetter<>();
        String[] strProducts = {"苹果手机","华为手机","扫地机器人","咖啡机"};
        //遍历数组
        for (int i = 0; i < strProducts.length; i++) {
            //添加到奖池
            stringProductGetter.addProduct(strProducts[i]);
        }
        //抽奖
        String product1 = stringProductGetter.getProduct();
        System.out.println("恭喜您，你抽中了：" + product1);
        System.out.println("================================");
        ProductGetter<Integer> integerProductGetter = new ProductGetter<>();
        int[] intProducts = {10000,5000,3000,500,300000};
        for (int i = 0; i < intProducts.length; i++) {
            integerProductGetter.addProduct(intProducts[i]);
        }
        Integer product2 = integerProductGetter.getProduct();
        System.out.println(product2);
    }
}

equals()和hashCode()方法

hashCode()方法和equals()方法是在Object类中就已经定义了的，所以在java中定义的任何类都会有这两个方法。原始的equals()方法用来比较两个对象的地址值，而原始的hashCode()方法用来返回其所在对象的物理地址

泛型类派生子类

子类是泛型类，子类和父类泛型类型要一致

class ChildGeneric<T> extends Generic<T>

子类不是泛型类，父类要明确泛型的数据类型

class ChildGeneric extends Generic<String>

泛型接口

接口中定义了一个泛型方法 doSomething，该方法接受一个类型为 T 的参数并返回一个类型为 T 的结果。使用该接口时，可以根据需要指定具体的类型参数

public interface MyInterface<T> {
    T doSomething(T t);
}

泛型方法

方法使用了一个类型参数 T，并返回了一个 T 类型的元素。这个方法可以用于任何类型的数组

public static <T> T getFirst(T[] array) {
    if (array.length == 0) {
        return null;
    }
    return array[0];
}

调用泛型方法，你需要在方法名之前指定它的类型参数

String[] words = {"hello", "world"};
String firstWord = getFirst(words);

调用了 getFirst 方法，并将字符串类型的数组传递给它。因为 getFirst 方法是一个泛型方法，编译器会推断出类型参数 T 是 String，所以该方法返回了第一个字符串元素 "hello"

类型通配符

类型通配符是Java中的一种特殊语法，用于表示未知类型。它使用问号（?）作为通配符，可以出现在泛型类、泛型方法、变量声明等位置，在泛型类或方法中，类型通配符可以用来表示任何类型

public class Box<T> {
    public void setValue(T value) { ... }
    public T getValue() { ... }
    // 使用类型通配符定义一个方法，可以接受任何类型的Box对象
    public void copyValue(Box<?> box) {
        T value = box.getValue(); // 读取box中的值
        setValue(value); // 将值设置到当前对象中
    }
}

类型通配符的上限

类型通配符的上限指定了通配符所代表的类型的最大边界。在 Java 中，可以使用 extends 关键字指定类型通配符的上限。例如，如果要创建一个泛型方法，该方法只能接受 Number 类型及其子类的参数，则可以使用以下语法：

public <T extends Number> void methodName(T parameterName) {
    // 方法实现
}

在这个例子中，类型通配符 <T extends Number> 的上限是 Number 类型，这意味着方法只能接受 Number 类型及其子类的参数

泛型通配符的下限

泛型通配符的下限指定了通配符所代表的类型的最小边界。在 Java 中，可以使用 super 关键字指定泛型通配符的下限。例如，如果要创建一个泛型方法，该方法只能接受 Integer 类型及其父类的参数，则可以使用以下语法：

public void methodName(List<? super Integer> parameterName) {
    // 方法实现
}

在这个例子中，泛型通配符 <? super Integer> 的下限是 Integer 类型的父类，这意味着该方法可以接受类型为 Integer、Number、Object 等超类的 List 参数

类型擦除

Java类型擦除是一种编译时的行为，它指在编译Java泛型代码时，将泛型类型信息擦除，转换成对应的原生类型，以保持与旧版Java语言代码的兼容性。具体解释如下：

Java泛型是在JDK1.5引入的，它允许程序员在定义类、接口或方法时使用一个或多个类型参数，用来限定该类、接口或方法中的某些数据类型。例如，我们可以定义一个泛型类List<T>，其中T表示元素的类型。在实例化该类时，我们需要提供具体的类型参数，例如List<String>或List<Integer>。

然而，在编译过程中，Java编译器会将泛型类型信息擦除掉，转换成对应的原生类型。例如，List<String>被擦除成List，List<Integer>也被擦除成List。意味着，运行时无法获取泛型类型信息，只能得到原生类型的信息。

这种类型擦除的行为对于Java语言的兼容性非常重要，因为它使得新版本的Java语言可以与旧版本的Java语言保持兼容。但是，它也带来了一些限制和挑战，例如无法使用泛型类型作为静态变量、局部变量、方法参数、异常类型等，还需要通过反射来获取泛型信息

泛型数组

泛型数组是指可以存储任意类型元素的数组，它在声明时需要指定元素类型的占位符，例如：

其中，T 是一个类型参数（type parameter），可以被任意类型所替换（例如 String、Integer 等）

T[] arr = new T[10]; // 使用占位符 T 声明一个长度为 10 的泛型数组

运行时，Java 虚拟机是无法获知 T 的实际类型的，因此无法创建一个真正的泛型数组。因此，上面的代码会导致编译错误。要想创建一个泛型数组，可以通过类型擦除和强制类型转换来实现，例如：

Object[] arr = new Object[10]; // 创建 Object 类型的数组
T t = (T) arr[0]; // 强制类型转换为 T 类型

这种方式虽然可以创建一个泛型数组，但不建议使用，因为强制类型转换可能会导致运行时错误。通常情况下，可以使用集合类（例如 ArrayList）来代替泛型数组，以避免这个问题

ArrayList<T> list = new ArrayList<>();
T t = list.get(0); // 直接获取 T 类型元素

这样就不需要使用强制类型转换来将 Object 类型转换为 T 类型了，同时也可以通过 ArrayList 的动态扩容特性方便地添加或删除元素

泛型反射

泛型是一种编程语言的特性，允许程序员可以在编译时不指定类型，而在运行时再确定类型，从而提高代码的灵活性和重用性。反射是Java中一个非常强大的特性，它使得程序可以在运行时获取类、方法、属性等的信息，并且可以动态地调用这些对象

泛型反射的实现就是对泛型类型进行反射操作。通过泛型反射可以获取泛型类型的参数类型、父类、接口等信息，还可以创建泛型对象、调用泛型方法等。为了实现泛型反射，需要使用到Java中的Type、ParameterizedType、GenericArrayType等相关的API

下面是一个简单的泛型反射示例：

public class Generic<T> {
    private T value;
    public Generic(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
}
public class Main {
    public static void main(String[] args) throws Exception {
        Generic<Integer> generic = new Generic<>(123);
        // 获取泛型参数类型
        Type type = generic.getClass().getGenericSuperclass();
        if (type instanceof ParameterizedType) {
            ParameterizedType paramType = (ParameterizedType) type;
            Type[] argTypes = paramType.getActualTypeArguments();
            System.out.println(argTypes[0]);
        }
        // 创建泛型对象
        Class<?> clazz = Class.forName("Generic");
        Constructor<?> constructor = clazz.getDeclaredConstructor(Object.class);
        constructor.setAccessible(true);
        Generic<String> generic2 = (Generic<String>) constructor.newInstance("hello");
        System.out.println(generic2.getValue());
    }
}

这个示例中定义了一个泛型类Generic<T>，并在其中获取泛型参数类型、创建泛型对象。运行结果为：

class java.lang.Integer
hello

🌼 结语：创作不易，如果觉得博主的文章赏心悦目，还请——点赞👍收藏⭐️评论📝

Java泛型

泛型

泛型类

总结

案例

equals()和hashCode()方法

泛型类派生子类

泛型接口

泛型方法

类型通配符

类型通配符的上限

泛型通配符的下限

类型擦除

泛型数组

泛型反射

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Java泛型

泛型

泛型类

总结

案例

equals()和hashCode()方法

泛型类派生子类

泛型接口

泛型方法

类型通配符

类型通配符的上限

泛型通配符的下限

类型擦除

泛型数组

泛型反射

热门文章

最新文章

相关课程

相关电子书

相关实验场景