0.前言

在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型,只在编译阶段有效。在编译过程中,正确检验泛型结果后,会将泛型的相关信息擦除,并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说,泛型信息不会进入到运行时阶段。
即:泛型类型在逻辑上看以看成是多个不同的类型,实际上都是相同的基本类型。

1.自定义泛型类

  1. 普通成员可以使用泛型(属性、方法都可)
  2. 泛型在创建对象时才会确定
  3. 使用泛型的数组不能初始化 T ts[] =new T[8],因为类加载时不能确定类型,就不能开辟空间
  4. 静态方法和属性不能使用泛型 ,原因同上
  5. 创建对象时如果要求传入泛型,但是创建对象时没有使用并传入,则默认传入object ```java package review.generic;

import java.util.ArrayList;

/**

  • 自定义泛型类 *
  • @Author rainbow
  • @Date 2022/5/15 15:40
  • @Version 1.0 **/ public class DefineClass { private E e; private T t; // static E e1; 禁止 // T ts[] =new T[8]; 禁止

    ArrayList list = new ArrayList<>();

    public DefineClass(E e, T t) {

    1. this.e = e;
    2. this.t = t;

    }

    //方法使用泛型 public E getE() {

    1. return e;

    } }

  1. <a name="Wk1hw"></a>
  2. # 2.自定义泛型接口
  3. 1. 接口类型在继承或实现接口时指定
  4. 1. 其他特点同泛型类
  5. ```java
  6. /**
  7. * 自定义泛型接口
  8. *
  9. * @Author rainbow
  10. * @Date 2022/5/15 16:02
  11. * @Version 1.0
  12. **/
  13. public interface DefineInterface<E, T> {
  14. // E e; 静态成员不能使用泛型,接口成员都是静态的
  15. E getE();
  16. T getT();
  17. //默认方法也可以使用泛型
  18. default E me() {
  19. return null;
  20. }
  21. }
  22. //接口可以继承接口
  23. interface A extends DefineInterface<String,Integer>{}

3.泛型方法

  1. 可以定义在普通类和泛型类中,可以使用类的泛型和自己的泛型
  2. 泛型方法被调用时才确定类型
  3. public 与 返回值中间非常重要,可以理解为声明此方法为泛型方法。
  4. 只有声明了的方法才是泛型方法,泛型类中的使用了泛型的成员方法并不是泛型方法。
  5. 表明该方法将使用泛型类型T,此时才可以在方法中使用泛型类型T。
  6. 与泛型类的定义一样,此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
  7. 如果静态方法要使用泛型的话,必须将静态方法也定义成泛型方法 。 ```java package review.generic;

/**

  • 自定义泛型方法 *
  • @Author rainbow
  • @Date 2022/5/15 16:18
  • @Version 1.0 **/ public class DefineMethod { private E e;

    public DefineMethod(E e) {

    1. this.e = e;

    }

    //不是泛型方法,只是使用了类泛型的方法 public E getE() {

    1. return e;

    }

    //这才是泛型方法, 是标志 public T methodT(T t) {

    1. return t;

    } //静态泛型方法 public static void printClass(T t){

    1. System.out.println(t.getClass());

    } public static void main(String[] args) {

    1. DefineMethod<Integer> d = new DefineMethod<>(1);
    2. //调用泛型方法
    3. System.out.println(d.methodT("heihei"));
    4. System.out.println(d.methodT(12));
    5. //调用静态泛型方法
    6. DefineMethod.printClass(12);

    } } ```

    4.泛型边界(继承)与通配符

    1. <?> 支持任意类型
    2. 泛型不支持继承,List list=new ArrayList (); 是错误的
    3. 在使用泛型的时候,还可以为传入的泛型类型实参进行上下边界的限制
    4. <? extends Number> 支持Number及其子类,规定了上限
    5. <? super Number> 支持number及其父类,不限于直接父类,规定了下限 ```java package review.generic;
    6. import java.util.ArrayList; import java.util.List;

      /**

      • 泛型继承与通配符 *
      • @Author rainbow
      • @Date 2022/5/15 16:38
      • @Version 1.0 **/ public class Extends { //上限 public static void print(List<? extends Number> list) {

        1. System.out.println(list);

        } //下限 public static void print1(List<? super Number> list) {

        1. System.out.println(list);

        }

        public static void main(String[] args) {

        1. ArrayList<Integer> integers = new ArrayList<>();
        2. ArrayList<String> str = new ArrayList<>();
        3. ArrayList<Object> obj = new ArrayList<>();
        4. integers.add(11);
        5. str.add("ass");
        6. obj.add(11);
        7. Extends.print(integers);
        8. //报错,因为string不是number子类

        // Extends.print(str);

        1. Extends.print1(obj);
        2. //报错,因为Integer不是number父类

        // Extends.print1(integers);

        } }

      ```