3

引入泛型的主要目标有以下几点:

类型安全

  • 泛型的主要目标是提高 Java 程序的类型安全
  • 编译时期就可以检查出因 Java 类型不正确导致的 ClassCastException 异常
  • 符合越早出错代价越小原则

消除强制类型转换

  • 泛型的一个附带好处是,使用时直接得到目标类型,消除许多强制类型转换
  • 所得即所需,这使得代码更加可读,并且减少了出错机会

潜在的性能收益

  • 由于泛型的实现方式,支持泛型(几乎)不需要 JVM 或类文件更改
  • 所有工作都在编译器中完成
  • 编译器生成的代码跟不使用泛型(和强制类型转换)时所写的代码几乎一致,只是更能确保类型安全而已

使用方式

  • 泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
  • 类型参数的意义是告诉编译器这个集合中要存放实例的类型,从而在添加其他类型时做出提示,在编译时就为类型安全做了保证。
  • 参数类型可以用在类、接口和方法的创建中,分别称为泛型类泛型接口泛型方法

通配符

  • 有时候希望传入的类型有一个指定的范围,从而可以进行一些特定的操作,这时候就是通配符边界登场的时候了。

泛型中有三种通配符形式:

  • <?> 无限制通配符
  • <? extends E> extends关键字声明了类型的上界,表示参数化的类型可能是所指定的类型,或者是此类型的子类
  • <? super E> super关键字声明了类型的下界,表示参数化的类型可能是指定的类型,或者是此类型的父类

无限制通配符 <?>

  • 要使用泛型,但是不确定或者不关心实际要操作的类型,可以使用无限制通配符(尖括号里一个问号,即 <?> ),表示可以持有任何类型
  • 大部分情况下,这种限制是好的,但这使得一些理应正确的基本操作都无法完成。
private void swap(List<?> list, int i, int j){
    Object o = list.get(i);
    list.set(j,o);
}
  • 这个代码看上去应该是正确的,但 Java 编译器会提示编译错误,set 语句是非法的。编译器提示我们把方法中的 List<?> 改成List<Object> 。

? 和 Object 不一样吗?

  • List<?> 表示未知类型的列表,而 List<Object> 表示任意类型的列表。比如传入 List<String> ,这时 List 的元素类型就是 String,想要往 List 里添加一个 Object,这当然是不可以的。

上界通配符 < ? extends E>

在类型参数中使用 extends 表示这个泛型中的参数必须是 E 或者 E 的子类,这样有两个好处:

  • 如果传入的类型不是 E 或者 E 的子类,编译不成功
  • 泛型中调用使用 E 的方法,要不然必须强转成 E 才能调用

下界通配符 < ? super E>

在类型参数中使用 super 表示这个泛型中的参数必须是 E 或者 E 的父类。

private <E> void add(List<? super E> dst, List<E> src){
    for (E e : src) {
        dst.add(e);
    }
}
  • dst 类型 “大于等于” src 的类型,这里的“大于等于”是指 dst 表示的范围比 src 要大,因此装得下 dst 的容器也就能装 src。向上转型总是合理的。

通配符比较

  • 无限制通配符 <?> 和 Object 有些相似,用于表示无限制或者不确定范围的场景。<?> 相当于 <? extends Object>
  • < ? extends E> 用于灵活读取,使得方法可以读取 E 或 E 的任意子类型的容器对象。
  • < ? super E> 用于灵活写入或比较,使得对象可以写入父类型的容器,使得父类型的比较方法可以应用于子类对象。
  • 为了获得最大限度的灵活性,要在表示 生产者或者消费者 的输入参数上使用通配符,使用的规则就是:生产者有上限消费者有下限PECS: producer-extends, costumer-super
  • T 的生产者的意思就是结果会返回 T (get),这就要求返回一个具体的类型,必须有上限才够具体;
  • T 的消费者的意思是要操作 T (set),这就要求操作的容器要够大,所以容器需要是 T 的父类,即 super T;
 private  <E extends Comparable<? super E>> E max(List<? extends E> e1){
        if (e1 == null){
            return null;
        }
        
        Iterator<? extends E> iterator = e1.iterator();
        E result = iterator.next();
        while (iterator.hasNext()){
            E next = iterator.next();
            if (next.compareTo(result) > 0){
                result = next;
            }
        }
        return result;
    }
  • 要进行比较,所以 E 需要是可比较的类,因此需要 extends Comparable<…>
  • Comparable<? super E> 要对 E 进行比较,即 E 的消费者,所以需要用 super
  • 而参数 List<? extends E> 表示要操作的数据是 E 的子类的列表。

类型擦除

Java 中的泛型和 C++ 中的模板有一个很大的不同:

  • C++ 中模板的实例化会为每一种类型都产生一套不同的代码,这就是所谓的代码膨胀。
  • Java 中并不会产生这个问题。虚拟机中并没有泛型类型对象,所有的对象都是普通类。

  • 在 Java 中,泛型是 Java 编译器的概念,用泛型编写的 Java 程序和普通的 Java程序基本相同,只是多了一些参数化的类型同时少了一些类型转换。
  • 实际上泛型程序也是首先被转化成一般的、不带泛型的 Java 程序后再进行处理的,编译器自动完成了从 Generic Java 到普通Java 的翻译,Java 虚拟机运行时对泛型基本一无所知。
  • 当编译器对带有泛型的java代码进行编译时,它会去执行类型检查类型推断,然后生成普通的不带泛型的字节码,这种普通的字节码可以被一般的 Java 虚拟机接收并执行,这在就叫做类型擦除(type erasure)。
  • 实际上无论你是否使用泛型,集合框架中存放对象的数据类型都是 Object
List<String> strings = new ArrayList<>();
List<Integer> integers = new ArrayList<>();
System.out.println(strings.getClass() == integers.getClass());//true

上面代码输出结果并不是预期的 false,而是 true。其原因就是泛型的擦除。

实现原理

  • Java 编辑器会将泛型代码中的类型完全擦除,使其变成原始类型。
  • 接着 Java编译器会在这些代码中加入类型转换,将原始类型转换成想要的类型。这些操作都是编译器后台进行,可以保证类型安全。
  • 泛型就是一个语法糖,它运行时没有存储任何类型信息。

擦除导致的泛型不可变性

  • 协变:如果 A 是 B 的父类,并且 A 的容器(比如 List< A>)也是 B 的容(List< B > ) 的父类,则称之为协变的(父子关系保持一致)
  • 逆变:如果 A 是 B 的父类,但是 A 的容器 是 B 的容器的子类,则称之为逆变(放入容器就篡位了)
  • 不可变:不论 A B 有什么关系,A 的容器和 B 的容器都没有父子关系,称之为不可变。
  • Java 中数组是协变的,泛型是不可变的

如果想要让某个泛型类具有协变性,就需要用到边界。

总结

  • 泛型是通过擦除来实现的。因此泛型只在编译时强化它的类型信息,而在运行时丢弃(或者擦除)它的元素类型信息。擦除使得使用泛型的代码可以和没有使用泛型的代码随意互用。
  • 数组中不能使用泛型

Java 中 List<Object> 和原始类型 List 之间的区别?

  • 在编译时编译器不会对原始类型进行类型安全检查,却会对带参数的类型进行检查
  • 通过使用 Object 作为类型,可以告知编译器该方法可以接受任何类型的对象,比如String 或 Integer
  • 可以把任何带参数的类型传递给原始类型 List,但却不能把 List< String> 传递给接受 List< Object>的方法,因为泛型的不可变性,会产生编译错误。

区分原始类型和泛型变量的类型

  • 在调用泛型方法的时候,可以指定泛型,也可以不指定泛型。
  • 在不指定泛型的情况下,泛型变量的类型为该方法中的几种类型的同一个父类的最小级,直到Object。
  • 在指定泛型的时候,该方法中的几种类型必须是该泛型实例类型或者其子类。
public class Test2{  
    public static void main(String[] args) {  
        /**不指定泛型的时候*/  
        int i=Test2.add(1, 2); //这两个参数都是Integer,所以T为Integer类型  
        Number f=Test2.add(1, 1.2);//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Number  
        Object o=Test2.add(1, "asd");//这两个参数一个是Integer,以风格是Float,所以取同一父类的最小级,为Object  
  
                /**指定泛型的时候*/  
        int a=Test2.<Integer>add(1, 2);//指定了Integer,所以只能为Integer类型或者其子类  
        int b=Test2.<Integer>add(1, 2.2);//编译错误,指定了Integer,不能为Float  
        Number c=Test2.<Number>add(1, 2.2); //指定为Number,所以可以为Integer和Float  
    }  
      
    //这是一个简单的泛型方法  
    public static <T> T add(T x,T y){  
        return y;  
    }  
}  
  • 类型检查就是针对引用的,谁是一个引用,用这个引用调用泛型方法,就会对这个引用调用的方法进行类型检测,而无关它真正引用的对象。

燃烧你的梦
238 声望17 粉丝