Java_泛型

P1.为什么要使用泛型？

• 泛型 => 标签

  • 把元素的类似设置为一个参数，这个参数就叫泛型

  • 允许在定义类、接口时，通过一个标识表示类中某个属性的类型或者某个方法的返回值类型及参数类型。这个类型参数将在使用时确定

    • 即，传入实际的类型参数，也称为类型实参

• 参数化类型

• 泛型的类型不能是基本类型，而要使用它的包装类

• 避免强转操作

• 类型推断

  • jdk1.7的一个新特性

  • 可以省略创建对象的泛型类型

  • List<String> list = new List<>();

• T、E

• K、V

P2.在集合中使用泛型

• 集合接口或者集合类在jdk5.0时都修改为带泛型的结构

• 在实例化集合类时，可以指明具体的泛型类型

• 指明完以后，在集合类或接口中凡是定义类或接口时，内部结构使用到类的泛型的位置，都指定为实例化时的泛型类型

• 泛型的类型必须是类，不能是基本数据类型

• 如果实例化时，没有指明泛型的类型。默认类型为java.lang.Object

P3.自定义泛型结构

• 泛型类、泛型接口；泛型方法

泛型类、泛型接口

• 父类有泛型，子类可以选择保留泛型或者指定泛型类型

  • 子类不保留父类的泛型 => 按需实现

    • 没有类型 => 擦除

      • public class SubOrder extends Order {}

        • 相当于：public class SubOrder extends Order<Object> {}

    • 具体类型

      • public class SubOrder extends Order<Integer> {}

  • 子类保留父类的泛型 => 泛型子类

    • 全部保留

      • public class SubOrder<K, V> extends Order<K, V> {}

      • public class SubOrder<K, V, A, B> extends Order<K, V> {}

    • 部分保留

      • public class SubOrder<V> extends Order<Integer, V> {}

      • public class SubOrder<V, A, B> extends Order<Integer, V> {}

• 定义泛型类构造器时，不要加泛型

  • public Order() {}

• 泛型不同的引用不能相互赋值

• 尽管在编译时ArrayList<Sting>和ArrayList<Integer>是两种类型，但在运行时只有一个ArrayList被加载到JVM中

• 泛型如果不指定，将被擦除。泛型对应的类型都按照Object来处理的，但不等价于Object

• 异常类不能是泛型

• 不能使用new E[]

  • 但能使用E[] elements = (E[])new Object[capacity];

泛型方法

• 静态方法中不能使用类的泛型

• 如下方法都不是泛型方法：

  • public T getOrderT() { return orderT; }

  • public void setOrderT(T orderT) { this.orderT = orderT; }

  • public String toString() { System.out.println(orderT); }

• 泛型方法：在方法中出现了泛型结构

  • 其泛型参数与类(或接口)的泛型参数没有任何关系

  • 泛型方法的类或接口可以不是带泛型的

• public <E> list<E> fun(E[] arr) {}

  • <E> => 告诉编译器，E是一个泛型而不是类

• public static <E> list<E> fun(E[] arr) {}

P4.泛型在继承方面的体现

• List<String>和List<Object>之间不具有子父类关系

• List<String>和ArrayList<String>之间有子/父类、接口/实现类的关系

• List<String> bean1和ArrayList<Integer>之间也不具有子/父类、接口/实现类的关系

P5.通配符的使用

• 通配符 => ?

• List<?>是List<String>和List<Integer>的公共父类

  • List<Integer>和List<Integer>没有关系

 @Test
 public void test() {
   List<String> list1 = null;
   List<Integer> list2 = null;
 ​
   List<?> list = null;
 ​
   // List<Integer>和List<Integer>没有关系
   // List<?>是List<String>和List<Integer>的公共父类
   list = list1;
   list = list2;
 }

 public void print(List<?> list) {
   Iterator<?> iterator = list.iterator();
   while (iterator.hasNext()) {
       Object obj = iterator.next();
   }
 }

• 对于List<?>，就不能向其内部添加数据，除了null

• 但是可以读List<?>，只是读出来的对象都是Object类型

• 有限制的通配符

  • <? extends Number> => (无穷小,Number] => ≤

    • 只允许泛型为Number及其子类的引用调用

    • G<? extends A>可以作为G<A>和G<B>的父类，其中B是A的子类

  • <? super Number> => [Number,无穷大) => ≥

    • 只允许泛型为Number及其父类的引用调用

    • G<? superA>可以作为G<A>和G<B>的父类，其中B是A的父类

  • <? extends Comparable>

    • 只允许泛型为实现Comparable接口的实现类的引用调用