背景

先来看一个例子：

  1. public static void main(String[] args) {
  2.     ArrayList list = new ArrayList();
  3.     list.add("java");
  4.     list.add(100);
  5.     list.add(true);
  7.     for(int i = 0; i < list.size(); i++) {
  8.         Object obj = list.get(i);
  9.         String str = (String)obj;
  10.         System.out.println(str);
  11.     }
  12. }

以上程序在编译期间没有问题，而在运行出错，报java.lang.ClassCastException，提示说Integer类型不能转换为String类型。

image.png
添加泛型：

  1. public static void main(String[] args) {
  2.     ArrayList<String> list = new ArrayList<>();
  3.     list.add("java");
  4.     list.add("python");
  5.     list.add("golang");
  7.     for(int i = 0; i < list.size(); i++) {
  8.         String str = list.get(i);
  9.         System.out.println(str);
  10.     }
  11. }

声明集合中的类型为String类型，不会报错。

image.png

image.png
代码复用、类型安全

泛型类

image.png
定义一个泛型类的例子：

  1. public class Generic<T> {
  2.     // key这个成员变量的类型为T，T的类型由外部类调用该类时指定
  3.     private T key;
  4.     // 泛型构造方法形参key的类型也为T，T的类型由外部指定
  5.     public Generic(T key) {
  6.         this.key = key;
  7.     }
  9.     public T getKey(){
  10.         return key;
  11.     }
  12. }

T：是由外部使用类使用该类对象时指定。

image.png
编写上面泛型类的测试方法：

  1. // 只编写了一个泛型类 Generic，就达到了代码复用
  3. Generic<String> gen_str = new Genertic<>("abc");
  4. String k1 = gen_str.getKey();
  5. System.out.println("k1: " + k1);
  7. Generic<Integer> gen_int = new Genertic<>(123);
  8. int k2 = gen_int.getKey();
  9. System.out.println("k2: " + k2);
  11. // 泛型类在创建对象时，没有指定类型，将按照Object类型来操作。
  13. Generic gen_obj = new Genertic(123);
  14. Object k3 = gen_obj.getKey();
  15. System.out.println("k3: " + k3);
  17. // 泛型类不支持基本数据类型，即<>中不能为int、long、float等
  19. // 同一个泛型类，如Generic，根据不同的数据类型创建的对象，本质上是同一类型。
  20. System.out.println(gen_str.getClass());        // 打印Generic的类路径
  21. System.out.println(gen_int.getClass());        // 打印Generic的类路径（和上一句一样）

注意点：
image.png

泛型类实际案例

需求：公司年会上有抽奖品的，也有抽现金的，编写一个抽奖器类完成功能

  1. // 抽奖器类
  2. public class ProGetter<T> {
  3.     Random random = new Random();
  4.     // 奖品，奖品(String)或奖金(int)
  5.     private T product;
  6.     // 奖品池
  7.     List<T> list = new ArrayList<>();
  8.     // 添加奖品到奖品池
  9.     public void addProduct(T t) {
  10.         list.add(t);
  11.     }
  12.     // 抽奖
  13.     public T getProduct(){
  14.         list.get(random.nextInt(list.size()));
  15.         return product;
  16.     }
  17. }
  19. // 测试类
  20. class TestProduct{
  21.     // 创建抽奖器对象，指定数据类型
  22.     ProGetter<String> str_pro = new ProGetter<>();
  23.     String[] pros = {"iphone 13", "Huawei P50", "Lenovo Y900P", "Beats"};
  24.     for(String s : pros) {
  25.         str_pro.addProduct(s);
  26.     }
  27.     // 抽奖
  28.     String pro = str_pro.getProduct();
  29.     System.out.println("恭喜您，你抽中了: " + pro);
  30.     //-------------------------------------------------
  31.     ProGetter<Integer> int_pro = new ProGetter<>();
  32.     int[] cash = {3000, 5000, 666, 888, 10000};
  33.     for(int c : cash) {
  34.         int_pro.addProduct(c);
  35.     }
  36.     // 抽奖
  37.     int pro = int_pro.getProduct();
  38.     System.out.println("恭喜您，你抽中了: " + pro);
  39. }

泛型类派生子类

image.png

泛型接口

image.png
image.png
看个具体例子：

  1. // 定义一个泛型接口
  2. public interface Generator<T> {
  3.     T getKey();
  4. }
  6. // 实现了泛型接口的类，实现类不是泛型类（上面的情况一）
  7. public class Apple implements Generator<String> {
  8.     @Override
  9.     public String getKey() {
  10.         return "hello";
  11.     }
  12. }
  1. // 实现类也是泛型类（上面情况二）
  2. // 泛型类的类型还可以扩充，如<T, E, K>，但是必须得包含接口的泛型类型，否则编译报错
  3. public class Pair<T> implements Generator<T> {
  4.     private T key;
  5.     @Override
  6.     public T getKey() {
  7.         return key;
  8.     }
  9. }

泛型方法

image.png
上面泛型类中定义的方法的返回值定义为T类型，在此声明，此方法不是泛型方法，如上面的代码块中定义的Pair泛型类中的getKey成员方法就不是泛型方法。
image.png
注意点：
image.png
例子：

  1. // 抽奖器类
  2. public class ProGetter<T> {
  3.     Random random = new Random();
  4.     // 奖品，奖品(String)或奖金(int)
  5.     private T product;
  6.     // 奖品池
  7.     List<T> list = new ArrayList<>();
  8.     // 添加奖品到奖品池
  9.     public void addProduct(T t) {
  10.         list.add(t);
  11.     }
  12.     // 抽奖，不是泛型方法
  13.     public T getProduct(){
  14.         list.get(random.nextInt(list.size()));
  15.         return product;
  16.     }
  18.     /**
  19.         定义一个泛型方法
  20.         <E> 是泛型标识，是具体类型，由调用方法的时候指定。
  21.     */
  22.     public <E> getProduct(ArrayList<E> list) {
  23.         return list.get(random.nextInt(list.size()));
  24.     }
  25. }
  27. // 测试类
  28. public class TestPro {
  29.     // 创建抽奖器对象，指定数据类型
  30.     ProGetter<Integer> pro = new ProGetter<>();
  31.     // 调用泛型类的成员方法，方法的返回值类型必须跟泛型类定义的类型Integer一致
  32.     int[] cash = {3000, 5000, 666, 888, 10000};
  33.     for(int c : cash) {
  34.         pro.addProduct(c);
  35.     }
  36.     Integer product = pro.getProduct();
  37.     System.out.println(product + "\t" + product.getClass().getSimpleName());
  38.     //*************************************************************************
  39.     ArrayList<String> strList = new ArrayList<>();
  40.     list.add("手机");
  41.     list.add("服务器");
  42.     list.add("显卡");
  43.     // 调用泛型方法，类型通过调用方法时指定
  44.     String prize = pro.getProduct(strList);
  45.     System.out.println(prize + "\t" + prize.getClass().getSimpleName());
  46. }

泛型方法支持可变参数
image.png

  1. // 定义一个是可变参数的且是静态的泛型方法
  2. public static <E> void print(E... e) {
  3.     for(int i = 0; i < e.length; i++) {
  4.         System.out.print(i + "\t");
  5.     }
  6. }
  7. // 测试一下：
  8. ProGetter。print(1, 2, 3, 4, 5);

image.png

  1. // 静态的泛型方法，采用多个泛型
  2. public static <T, E, K> void printType(T t, E e, K k) {
  3.     System.out.println(t + "\t" + t.getClass().getSimpleName());
  4.     System.out.println(e + "\t" + e.getClass().getSimpleName());
  5.     System.out.println(k + "\t" + k.getClass().getSimpleName());
  6. }
  8. // 测试一下
  9. ProGetter.printType(100, "java", true);

类型通配符

image.png
例子：

  1. public class Box<E> {
  2.     private E first;
  4.     public E getFirst() {
  5.         return first;
  6.     }
  8.     public void setFirst() {
  9.         this.first = first;
  10.     }
  11. }
  13. // 测试
  14. public class TestBox{
  15.     public static void showBox(Box<Number> box) {
  16.         Number first = box.getFirst();
  17.         System.out.println(first);
  18.     }
  20.     public static void showBox(Box<Integer> box) {
  21.         Number first = box.getFirst();
  22.         System.out.println(first);
  23.     }
  25.     // 上面两个方法不叫重载，会报错，只能存在一个，使用泛型通配符解决
  26.     // ? 表示可以传递任意类型
  27.     public static void showBox(Box<?> box) {
  28.         Object first = box.getFirst();
  29.         System.out.println(first);
  30.     }
  31. }

类型通配符的上限

image.png

  1. class Animal{
  3. }
  5. class Cat extends Animal{
  7. }
  9. class MiniCat extends Cat{
  11. }
  13. // 测试
  14. public class TestUp{
  16.     public static void showAnimal(ArrayList<? extends Cat> list) {
  17.         for(int i = 0; i < list.size(); i++) {
  18.             Cat cat = list.get(i);
  19.             System.out.println(cat);
  20.         }
  22.         list.add(new Cat());        // 报错，上线通配符不能添加元素
  23.         list.add(new miniCats);        // 同样报错
  24.     }
  26.     public static void main(String[] args){
  27.         ArrayList<Animal> animals = new ArrayList<>();
  28.         ArrayList<Cat> cats = new ArrayList<>();
  29.         ArrayList<MiniCat> miniCats = new ArrayList<>();
  31.         showAnimal(animals);    //报错，上限只能是Cat
  32.         showAnimal(cats);
  33.         showAnimal(miniCats);   
  34.     }
  35. }

类型通配符的下限

image.png

  1. class Animal{
  3. }
  5. class Cat extends Animal{
  7. }
  9. class MiniCat extends Cat{
  11. }
  13. // 测试
  14. public class TestDown{
  16.     public static void showAnimal(ArrayList<? extends Cat> list) {
  17.         for(int i = 0; i < list.size(); i++) {
  18.             Cat cat = list.get(i);
  19.             System.out.println(cat);
  20.         }
  22.         list.add(new Cat());        // 下限通配符添加元素不会报错
  23.         list.add(new Animal());        // 不会报错
  24.     }
  26.     public static void main(String[] args){
  27.         ArrayList<Animal> animals = new ArrayList<>();
  28.         ArrayList<Cat> cats = new ArrayList<>();
  29.         ArrayList<MiniCat> miniCats = new ArrayList<>();
  31.         showAnimal(animals);    
  32.         showAnimal(cats);
  33.         showAnimal(miniCats);   //报错，下限只能是Cat
  34.     }
  35. }

jdk中下线通配符的使用

类型擦除

image.png

java中所有的泛型信息只存在于编译阶段，编译完成后，所有的泛型信息将被擦除掉

无限制类型擦除

image.png

泛型无限制类型擦除，编译结束后，把T类型全部替换为Object类型

可以通过反射来得到编译后T类型被擦除后得到的类型：

  1. // 通过反射，拿到Erasure的key的数据类型
  2. class TestErasure{
  3.     psvm(){
  4.         Erasure<Integer> erasure = new Erasure<>();
  5.         // 利用反射，获取Erasure类的字节码文件的Class类对象
  6.         Class<? extends Erasure> clz = erasure.getClass();
  7.         // 获取所有成员变量
  8.         Field[] fields = clz.getDeclaredFields();
  9.         for(Field field : fields) {
  10.             // 打印成员变量的名称和类型
  11.             System.out.println(field.getName() + ":" + field.getType().getSimpleName());
  12.         }
  13.     }
  14. }
  16. 运行结果：
  17. // key:Object

有限制类型擦除

image.png

  1. // 通过反射，拿到Erasure的key的数据类型
  2. class TestErasure{
  3.     psvm(){
  4.         Erasure<Integer> erasure = new Erasure<>();
  5.         // 利用反射，获取Erasure类的字节码文件的Class类对象
  6.         Class<? extends Erasure> clz = erasure.getClass();
  7.         // 获取所有成员变量
  8.         Field[] fields = clz.getDeclaredFields();
  9.         for(Field field : fields) {
  10.             // 打印成员变量的名称和类型
  11.             System.out.println(field.getName() + ":" + field.getType().getSimpleName());
  12.         }
  13.     }
  14. }
  16. 运行结果：
  17. // key:Number

擦除泛型方法中类型定义的参数

image.png

  1. public class Erasure<T extends Number> {
  2.     ....;
  3.     // 添加泛型方法
  4.     public <T extends Number> T show(T t) {
  5.         return t;
  6.     }    
  7. }
  9. class TestErasure{
  10.     psvm(){
  11.         Erasure<Integer> erasure = new Erasure<>();
  12.         // 利用反射，获取Erasure类的字节码文件的Class类对象
  13.         Class<? extends Erasure> clz = erasure.getClass();
  14.         // 获取所有成员方法
  15.         Methods[] methods = clz.getDeclaredMethods();
  16.         for(Method method : methods) {
  17.             // 打印成员方法的名称和返回值类型
  18.             System.out.println(method.getName() + ":" + mathod.getReturnType().getSimpleName());
  19.         }
  20.     }
  21. }
  23. // 结果：
  24. getKey:Number
  25. show:List
  26. setKey:void

桥接方法

image.png

  1. // 编写泛型接口和实现类
  3. // 测试类
  4. psvm{
  5.     // 利用反射，获取InfoImpl类的字节码文件的Class类对象
  6.     Class<InfoImpl> infoClass = InfoImpl.class;
  7.     // 获取所有成员方法
  8.     Method[] methods = infoClass.getDeclaredMethods();
  9.     // 
  10.     for(Method method : methods) {
  11.         // 打印成员方法的名称和返回值类型
  12.         System.out.println(method.getName() + ":" + mathod.getReturnType().getSimpleName());
  13.     }
  14. }
  15. // 结果：
  16. info:Integer 
  17. info:Object （多了个方法，编译器替我们去生成的）

泛型数组

image.png
真正开发中一般都是用泛型集合，很少使用泛型数组。

泛型和反射