Java通识基础26（泛型）

浅层了解——泛型是定义集合类时所需要的

用来固定集合类的类型

  • 集合类在初始化的时候默认的的类型是Object，调用时总是需要用到强制类型转换
  • 集合类在初始化的时候默认的的类型是Object，所以任意元素都可以添加到集合类中

在集合类使用泛型和菱形语法的简例：

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class NoGeneric {
  5.     public static void main(String[] args) {
  6.         List<String> list=new ArrayList<>();
  7.         list.add("Java");
  8.         list.add("Python");
  9.         list.add("JS");
  10.         for (Object st:list){
  11.             System.out.println(st);
  12.         }
  13.         System.out.println(list);
  14.     }
  15. }

自定义的泛型类

在自定义的类中定义泛型

根据该类创建对象或者调用对象的方法时可以可以根据泛型传入实际类型

这样的优点便是不仅让传入的值可以借助泛型动态改变，而传入的类型也可以动态改变

  • 方法：程序为方法定义几个形参，调用方法就会传入几个实参
  • 泛型：程序为类或者方法传入几个泛型，使用雷和方法的时候后就会传入几个实际类型
  1. public class Apple<T,E> {
  2.     private T name;
  3.     private E weight;
  4. //在自定义类中定义了泛型，就可将该类体中使用这两个泛型
  5.     //好处是变量的指定不会固化
  6.     public void setName(T name) {
  7.         this.name = name;
  8.     }
  10.     public T getName() {
  11.         return name;
  12.     }
  14.     public void setWeight(E weight) {
  15.         this.weight = weight;
  16.     }
  18.     public E getWeight() {
  19.         return weight;
  20.     }
  21. }
  1. ublic class AppleTest {
  2.     public static void main(String[] args) {
  3.         Apple<String, Float> app1 = new Apple<>();
  4.         app1.setName("Java");
  5.         System.out.println(app1.getName());
  6.         Apple<Integer, String> app2 = new Apple<>();
  7.         app2.setName(233);
  8.         System.out.println(app2.getName());
  9.         Apple app3=new Apple();
  10.         app3.setName("Java"); //Object类型
  11.         String s=(String)app3.getName();
  12.         System.out.println(s);
  13.     }
  14. }

使用泛型派生子类

子类可以完全继承父类的泛型

  1. class BlackApple<T,E> extends Apple<T,E>{
  3. }

也可以相应的为父类泛型传入实际类型

  1. class GreenApple extends Apple<String,Float>{
  3. }

或者是创建的时候自己重新定义泛型

  1. class RedApple<A> extends Apple{
  3. }

原始类型

虽然程序定义了泛型类，但当我们练尖括号都不加的时候，系统就会默认定义原始类型

——其目的是与泛型出现之前的代码保持兼容

缺点

  • 只要使用了原始类型，Java就会警告
  • 原始类型会被编译器当做Object来处理，此后使用需要用到强制类型转换

泛型不支持形变！——并不存在的泛型类

List<String>、List<Integer>看上去很像List的子接口

但是他们没有真正的类文件，使用的类已仍然是List

类型通配符

当我们使用泛型类，程序应该为泛型形参传入实际的类型参数，但由于不确定应该传入哪种类型，所以就用?来当做通配符

  1. import java.util.List;
  3. public class WildcardTest {
  4.     //List<?>表示需要为此处的泛型传入实际的类型，但不确定使用哪种类型，所以使用了通配符
  5.     public static void foreach(List<?> list){
  6.         for (Object o : list) {
  7.             System.out.println(o);
  8.         }
  9.     }
  11.     public static void main(String[] args) {
  12.         List<Integer> inList= List.of(2, 3, 6);
  13.         WildcardTest.foreach(inList);
  14.         List<String> strList= List.of("fk","cao","cyka");
  15.         WildcardTest.foreach(strList);
  16.     }
  17. }
  • 使用了通配符之后，通配符本身可以代表任何类型

通配符存在的限制

通配符虽然可以代表任何类型，但Java永远无法确定通配符到底代表了什么实际类型

  • 如果你尝试向List<?>添加List<Integer>，Java有可能会让List<?>引用List<Float>，也有可能是List<Double>，所以，程序会报错！

所以，通配符不能添加元素（Java也不清楚你添加的是什么类型的元素），只能删除元素

List<?>与List<Object>的区别

  • 前者可以被任何类型代替，当你有一个方法不确定使用的是哪一个实际类型时就可以使用通配符

  • List<Object>却固定对标Object，根据前题并不存在的泛型类可知我们无法用List<Object>代替任何其他类型，所以使用的时候避免不了强制类型转换

List<?>与List（原始类型）的区别

  • List<?>是保留泛型信息的，调用的时候可以存在类型上的约束
  • List不保留泛型信息，集合被赋值给List变量之后，他们的泛型信息都会被擦除！

类型通配符的上限

作用：

  • 仍然可以保留类型通配符的优势
  • 可以保证从集合取出的元素是某个类型或其任意的子类

语法：

List<? extands 上限>

规则：

  • 带上限的类型通配符的集合，同样只能取出元素，而且被取出的元素总是被当成“上限”类型来处理
  • List<类型>（只要尖括号中的类型是上限或其子类），那么List<类型>就可以被当成List<? extands 上限>
  1. import java.util.List;
  3. public class UpperLimit {
  4.     public static void main(String[] args) {
  5.         //定义一个List<Integer>类型
  6.         List<Integer>intList=List.of(2,3,6);
  7.         //List<? extands Number>为通配符上限
  8.         //类似于之前的通配符，它可以去除元素且取出的元素作为Number来处理
  9.         //只要尖括号中的类型是Number或者其子类
  10.         List<? extends Number>numList=intList;
  11.         //注意该集合只能取出元素，并且其所有元素都被扩展为Number类型
  12.         Number i=numList.get(0);
  13.         System.out.println(i);
  14.         List<Double> doublelist=List.of(2.2,2.3);
  15.         numList=doublelist;
  16.         Number q=numList.get(1);
  17.         System.out.println(q);
  18.     }
  19. }

从上面的例子不难看出，通配符上限的使用是为了给固有的泛型进行上向转型（向上扩展）

比如numList这一带上限的通配符从Integer或是Double泛型转换为了Number且固定为了Number

注意：带上限的通配符无法添加元素，因为我们不清楚该通配符的集合元素代表的是“上限”类型的哪一个子类，比如尝试在numList中添加Double元素，其集合元素可能是Integer，因此会报错

所以，同样的，带上限的通配符也只能取出元素

综上List<?>只是List<? extands 上限>的特例

综上List<?>等价于List<? extands Object>

举例

  1.     public static void listSum(List<Integer> list){
  2.         int sum=0;
  3.         for(Integer i:list){
  4.             sum+=i;
  5.         }
  6.     }

局限于该方法只能计算类型是整形的元素的之和

改进

  1.     public static Double listSum(List<? extends Number> list){
  2.         double sum=0;
  3.         for(Number i:list){
  4.             sum+=i.doubleValue();
  5.         }
  6.         return sum;
  7.     }

通过形参可得出此时该方法可以适用于泛型为Number的集合

类型通配符在自定义泛型的运用

  1. import java.util.List;
  3. public class UpperLimit {
  4.     public static void main(String[] args) {
  5.         Item<String> stringItem=new Item<>("java");
  6.         stringItem.printInfo("Juan");
  7.         Item<? extends Number> numItem;
  8.         numItem=new Item<Integer>(233);
  9.         numItem.getInfo();
  10.         //我们只知道numItem的泛型是Number以及其子类，但无法确定具体是哪一个子类
  11.         //System.out.println(numItem.printInfo(233));
  12.         //printInfo方法的参数是T，此时T代表的是上限为Number类型的通配符，但我们不清楚具体是哪一种类型，所以此对象的该方法永远无法被调用！
  13.     }
  14. class Item<T> {
  15.     private T info;
  17.     public Item(T info) {
  18.         this.info = info;
  19.     }
  21.     public void getInfo(){
  22.         System.out.println(info);
  23.     }
  25.     public void printInfo(T t) {
  26.         System.out.println("参数t为" + t);
  27.     }
  28. }

**重点总结1：

对于带上限的通配符的泛型类的实例而言

  • 只能取出元素——也就是说只能调用返回值为泛型的方法
  • 不能添加元素——不能调用参数为泛型的方法

——协变只能出不能进

类型通配符的下限

语法：

List<? super 下限>

规则

  • 与类型通配符的上限相反——只能添加元素，不能取出元素
  • 添加的元素必须是下限或者是下限的子类
  • 如果类A是类B的父类，那么List<A>就相当于List<? super B>的子类（此时只要求集合的泛型是B的父类具体是哪一个父类不确定）——这个概念被称作泛型逆变

**重点总结2：

对于带上限的通配符的泛型类的实例而言

  • 只能添加元素——也就是说只能调用参数为泛型的方法
  • 不能取出元素——不能调用返回值为泛型的方法——除非把返回值当做Objext处理

——逆变只能出不能进

泛型（形参）的上限

运用场景——

例如对于class A<T>意味着泛型T只需要是Object的子类，T可以是任意的类型

在某些时候，程序对于泛型T的要求只是某个类的子类，此时可以通过泛型上限来实现

语法猜也可以猜到：

class A<T extands 上限>

举例：

  1. public class Users1 <T extends Number> {
  2.     private T weight;
  4.     public void setWeight(T weight) {
  5.         this.weight = weight;
  6.     }
  8.     public T getWeight() {
  9.         return weight;
  10.     }
  11. }
  12. class UserTest{
  13.     public static void main(String[] args) {
  14.         Users1<Integer> u1=new Users1<>();
  15.         u1.setWeight(3);
  16.         System.out.println(u1.getWeight());
  17.         Users1<Double> u2=new Users1<>();
  18.         u2.setWeight(1.43);
  19.         System.out.println(u2.getWeight());
  20.     }
  21. }

泛型的上限可以是多个类型

多个泛型上限时，只能有一个类，可以有多个接口（Java语言的单继承性）

  1. import java.io.Serializable;
  2. //此处限定T必须是Number的子类，并且是Serializable和Comparable的接口
  3. public class Foo <T extends Number & Serializable & Comparable>{
  5. }

泛型方法

定义方法的时候，可以在修饰符与返回值类型之间用尖括号来定义额外的类型形参（泛型）

  • 泛型类和泛型方法的本质区别——

    • 如果在类中定义了泛型，那么该类中所有的方法都可以使用该泛型

    • 如果只是在方法中定义了泛型，那么只能在该方法中使用该泛型
      所以本质上相同，仅仅是作用域不同

  1. import java.util.ArrayList;
  2. import java.util.Collection;
  3. import java.util.Collections;
  5. public class Utils {
  6.     //将数组的元素复制到集合中
  7.     public static<T> void copyArraytoCollection(T[] from, Collection<T> to){
  8.         Collections.addAll(to, from);
  9.     }
  11.     public static void main(String[] args) {
  12.         String[] strA=new String[]{"java","love","gtn"};
  13.         Double[] strD=new Double[]{2.1,2.22,23.3};
  14.         Collection<Object> M1=new ArrayList<>();
  15.         copyArraytoCollection(strA,M1);
  16.         copyArraytoCollection(strD,M1);
  17.         System.out.println(M1);
  18.     }
  19. }

同理，对构造器使用泛型的时候，同样无需显示指定的泛型类型

  1. public class Utils<E> {
  3.     public <T> Utils(T info,E into){
  4.         System.out.println(info);
  5.     }
  7. }
  9. class UnitTest{
  10.     public static void main(String[] args) {
  11.         Utils u1=new Utils(11,"spt");
  12.         Utils u2=new Utils("lsr",22);
  13.         //声明时到指定类型的泛型
  14.         Utils <String>u3=new <Double>Utils("lsr",22.1);
  15.     }
  16. }

注意：此处显示指定的构造器类型，就不能使用菱形语法

总结——要么都显示指定，要么都不显示指定

泛型方法重载

由于泛型方法中的形参类型是动态改变的，而Java的方法重载是根据方法传入的形参类型区分的。

因此可以出现一种情况——Java程序中的两个形参列表看上去不同，但实际上是完全一样的

  1. import java.util.Collection;
  3. public class Mine {
  4.     public static <T> void copy(Collection<T> from, Collection<? super T> to){
  5.         to.addAll(from);
  6.     }
  7.     public static <T> void copy(Collection<? super T> from, Collection<? super T> to){
  8.         to.addAll(from);
  9.     }
  10. }

此时Java编译器无法准确区分两个方法，编译时会报错！

注意：在方法中引入泛型之后，方法的签名会变得更加灵活，要区分何时是方法重载

泛型擦除

存在目的是与早起程序保持兼容

当程序将一个带泛型信息的变量赋值给不带泛型信息的变量时，所有的泛型信息都会被丢失——泛型擦除

  1. import java.util.ArrayList;
  2. import java.util.List;
  4. public class Erase {
  5.     public static void main(String[] args) {
  6.         List<Integer> integerList=new ArrayList<>();
  7.         integerList.add(2);
  8.         integerList.add(14);
  9.         System.out.println(integerList.get(0));
  10.         //开始擦除
  11.         List list=integerList;
  12.         list.add("wtf");
  13.         //list擦除了所有的泛型信息，所有的元素都是Object
  14.         System.out.println(list);
  15.         Object i=list.get(0);
  16.         System.out.println(i);
  17.     }
  18. }