原文地址https://www.cnblogs.com/lzq198754/p/5780426.html

1.为什么需要泛型

泛型在Java中有很重要的地位,网上很多文章罗列各种理论,不便于理解,本篇将立足于代码介绍、总结了关于泛型的知识。希望能给你带来一些帮助。

先看下面的代码:

  1. List list = new ArrayList();
  2. list.add("CSDN_SEU_Cavin");
  3. list.add(100);
  4. for (int i = 0; i < list.size(); i++) {
  5. String name = (String) list.get(i); //取出Integer时,运行时出现异常
  6. System.out.println("name:" + name);
  7. }

本例向list类型集合中加入了一个字符串类型的值和一个Integer类型的值。(这样合法,因为此时list默认的类型为Object类型)。在之后的循环中,由于忘记了之前在list中也加入了Integer类型的值或其他原因,运行时会出现java.lang.ClassCastException异常。为了解决这个问题,泛型应运而生。

2.泛型的使用

Java泛型编程是JDK1.5版本后引入的。泛型让编程人员能够使用类型抽象,通常用于集合里面。

只要在上例中将第1行代码改成如下形式,那么就会在编译list.add(100)时报错。

  1. List<String> list = new ArrayList<String>();

通过List<String>,直接限定了list集合中只能含有String类型的元素,从而在上例中的第6行中,无须进行强制类型转换,因为集合能够记住其中元素的类型信息,编译器已经能够确认它是String类型了。

3.泛型只在编译阶段有效

看下面的代码:

  1. AyyayList<String> a = new ArrayList<String>();
  2. ArrayList b = new ArrayList();
  3. Class c1 = a.getClass();
  4. Class c2 = b.getClass();
  5. System.out.println(a == b); //true

上面程序的输出结果为true。所有反射的操作都是在运行时的,既然为true,就证明了编译之后,程序会采取去泛型化的措施,也就是说Java中的泛型,只在编译阶段有效。在编译过程中,正确检验泛型结果后,会将泛型的相关信息擦出,并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说,成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。

上述结论可通过下面反射的例子来印证:

  1. ArrayList<String> a = new ArrayList<String>();
  2. a.add("CSDN_SEU_Cavin");
  3. Class c = a.getClass();
  4. try{
  5. Method method = c.getMethod("add",Object.class);
  6. method.invoke(a,100);
  7. System.out.println(a);
  8. }catch(Exception e){
  9. e.printStackTrace();
  10. }

因为绕过了编译阶段也就绕过了泛型,输出结果为:

  1. [CSDN_SEU_Cavin, 100]

4.泛型类和泛型方法

如下,我们看一个泛型类和方法的使用例子,和未使用泛型的使用方法进行了对比,两者输出结果相同,在这里贴出来方便读者体会两者的差异。泛型接口的例子有兴趣可以去找一些资料,这里就不赘述了。

(1)使用泛型的情况

  1. public static class FX<T> {
  2. private T ob; // 定义泛型成员变量
  3. public FX(T ob) {
  4. this.ob = ob;
  5. }
  6. public T getOb() {
  7. return ob;
  8. }
  9. public void showTyep() {
  10. System.out.println("T的实际类型是: " + ob.getClass().getName());
  11. }
  12. }
  13. public static void main(String[] args) {
  14. FX<Integer> intOb = new FX<Integer>(100);
  15. intOb.showTyep();
  16. System.out.println("value= " + intOb.getOb());
  17. System.out.println("----------------------------------");
  18. FX<String> strOb = new FX<String>("CSDN_SEU_Calvin");
  19. strOb.showTyep();
  20. System.out.println("value= " + strOb.getOb());
  21. }

(2)不使用泛型的情况

  1. public static class FX {
  2. private Object ob; // 定义泛型成员变量
  3. public FX(Object ob) {
  4. this.ob = ob;
  5. }
  6. public Object getOb() {
  7. return ob;
  8. }
  9. public void showTyep() {
  10. System.out.println("T的实际类型是: " + ob.getClass().getName());
  11. }
  12. }
  13. public static void main(String[] args) {
  14. FX intOb = new FX(new Integer(100));
  15. intOb.showTyep();
  16. System.out.println("value= " + intOb.getOb());
  17. System.out.println("----------------------------------");
  18. FX strOb = new FX("CSDN_SEU_Calvin");
  19. strOb.showTyep();
  20. System.out.println("value= " + strOb.getOb());
  21. }

输出结果均为:

  1. T的实际类型是: java.lang.Integer
  2. value= 100
  3. ----------------------------------
  4. T的实际类型是: java.lang.String
  5. value= CSDN_SEU_Calvin

5.通配符

为了引出通配符的概念,先看如下代码:

  1. List<Integer> ex_int= new ArrayList<Integer>();
  2. List<Number> ex_num = ex_int; //非法的

上述第2行会出现编译错误,因为Integer虽然是Number的子类,但List<Integer>不是List<Number>的子类型。

假定第2行代码没有问题,那么我们可以使用语句ex_num.add(newDouble())在一个List中装入了各种不同类型的子类,这显然是不可以的,因为我们在取出List中的对象时,就分不清楚到底该转型为Integer还是Double了。

因此,我们需要一个在逻辑上可以用来同时表示为List<Integer>和List<Number>的父类的一个引用类型,类型通配符应运而生。在本例中表示为List<?>即可。下面这个例子也说明了这一点,注释已经写的很清楚了。

  1. public static void main(String[] args) {
  2. FX<Number> ex_num = new FX<Number>(100);
  3. FX<Integer> ex_int = new FX<Integer>(200);
  4. getData(ex_num);
  5. getData(ex_int);//编译错误
  6. }
  7. public static void getData(FX<Number> temp) { //此行若把Number换为“?”编译通过
  8. //do something...
  9. }
  10. public static class FX<T> {
  11. private T ob;
  12. public FX(T ob) {
  13. this.ob = ob;
  14. }
  15. }

6.上下边界

看了下面这个上边界的例子就明白了,下界FX<? supers Number>的形式就不做过多赘述了。

  1. public static void main(String[] args) {
  2. FX<Number> ex_num = new FX<Number>(100);
  3. FX<Integer> ex_int = new FX<Integer>(200);
  4. getUpperNumberData(ex_num);
  5. getUpperNumberData(ex_int);
  6. }
  7. public static void getUpperNumberData(FX<? extends Number> temp){
  8. System.out.println("class type :" + temp.getClass());
  9. }
  10. public static class FX<T> {
  11. private T ob;
  12. public FX(T ob) {
  13. this.ob = ob;
  14. }
  15. }

7.泛型的好处

(1)类型安全。

通过知道使用泛型定义的变量的类型限制,编译器可以更有效地提高Java程序的类型安全。

(2)消除强制类型转换。

消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。所有的强制转换都是自动和隐式的。

(3)提高性能。

  1. Lits list1 = new ArrayList();
  2. list1.add("CSDN_SEU_Cavin ");
  3. String str1 = (String)list1.get(0);
  1. List<String> list2 = new ArrayList<String>();
  2. list2.add("CSDN_SEU_Cavin ");
  3. String str2 = list2.get(0);

对于上面的两段程序,由于泛型所有工作都在编译器中完成,javac编译出来的字节码是一样的(只是更能确保类型安全),那么何谈性能提升呢?是因为在泛型的实现中,编译器将强制类型转换插入生成的字节码中,但是更多类型信息可用于编译器这一事实,为未来版本的 JVM 的优化带来了可能。

8.泛型使用的注意事项

(1)泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。

(2)泛型的类型参数可以有多个。

(3)不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的,编译时会出错。

  1. if(ex_num instanceof FX<Number>){
  2. }

(4)不能创建一个确切的泛型类型的数组。下面使用Sun的一篇文档的一个例子来说明这个问题:

  1. List<String>[] lsa = new List<String>[10]; // Not really allowed.
  2. Object o = lsa;
  3. Object[] oa = (Object[]) o;
  4. List<Integer> li = new ArrayList<Integer>();
  5. li.add(new Integer(3));
  6. oa[1] = li; // Unsound, but passes run time store check
  7. String s = lsa[1].get(0); // Run-time error: ClassCastException.

这种情况下,由于JVM泛型的擦除机制,在运行时JVM是不知道泛型信息的,所以可以给oa[1]赋上一个ArrayList<Integer>而不会出现异常,但是在取出数据的时候却要做一次类型转换,所以就会出现ClassCastException,如果可以进行泛型数组的声明,上面说的这种情况在编译期将不会出现任何的警告和错误,只有在运行时才会出错。

下面采用通配符的方式是被允许的:

    1. List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.
    2. Object o = lsa;
    3. Object[] oa = (Object[]) o;
    4. List<Integer> li = new ArrayList<Integer>();
    5. li.add(new Integer(3));
    6. oa[1] = li; // Correct.
    7. Integer i = (Integer) lsa[1].get(0); // OK

Java泛型三:Java泛型详解的更多相关文章

  1. Java网络编程和NIO详解9:基于NIO的网络编程框架Netty

    Java网络编程和NIO详解9:基于NIO的网络编程框架Netty 转自https://sylvanassun.github.io/2017/11/30/2017-11-30-netty_introd ...

  2. JAVA反射概念及使用详解(超详细)

    JAVA反射概念及使用详解 一.什么是反射? 反射:框架设计的灵魂 框架:半成品软件.可以在框架的基础上进行软件开发,简化编码 反射:将类的各个组成部分封装为其他对象,这就是反射机制 ​ 好处: ​ ...

  3. java中的io系统详解 - ilibaba的专栏 - 博客频道 - CSDN.NET

    java中的io系统详解 - ilibaba的专栏 - 博客频道 - CSDN.NET 亲,“社区之星”已经一周岁了!      社区福利快来领取免费参加MDCC大会机会哦    Tag功能介绍—我们 ...

  4. Java中的main()方法详解

    在Java中,main()方法是Java应用程序的入口方法,也就是说,程序在运行的时候,第一个执行的方法就是main()方法,这个方法和其他的方法有很大的不同,比如方法的名字必须是main,方法必须是 ...

  5. [译]Java Thread join示例与详解

    Java Thread join示例与详解 Java Thread join方法用来暂停当前线程直到join操作上的线程结束.java中有三个重载的join方法: public final void ...

  6. Java虚拟机之垃圾回收详解一

    Java虚拟机之垃圾回收详解一 Java技术和JVM(Java虚拟机) 一.Java技术概述: Java是一门编程语言,是一种计算平台,是SUN公司于1995年首次发布.它是Java程序的技术基础,这 ...

  7. Java面试题04-final关键字详解

    Java面试题04-final关键字详解 本篇博客将会讨论java中final关键字的含义,以及final用在什么地方,感觉看书总会有一些模糊,而且解释的不是很清楚,在此做个总结,以备准备面试的时候查 ...

  8. Elasticsearch java api 基本搜索部分详解

    文档是结合几个博客整理出来的,内容大部分为转载内容.在使用过程中,对一些疑问点进行了整理与解析. Elasticsearch java api 基本搜索部分详解 ElasticSearch 常用的查询 ...

  9. java 关键字final static native详解

    java 关键字native static final详解 一.final 根据程序上下文环境,Java关键字final有"这是无法改变的"或者"终态的"含义, ...

  10. Java I/O : Java中的进制详解

    作者:李强强 上一篇,泥瓦匠基础地讲了下Java I/O : Bit Operation 位运算.这一讲,泥瓦匠带你走进Java中的进制详解. 一.引子 在Java世界里,99%的工作都是处理这高层. ...

随机推荐

  1. tinycore remaster方法

    11.1. PrerequisitesYou need a Linux distribution with the required programs available:cpio, tar, gzi ...

  2. layDate/DatePicker日期时间空间

    真心不错,果断收藏了. 1.示例与效果 2.更多示例与皮肤 补充说明:My97DatePicker日期时间插件 的使用 1.示例与效果 2. 更多 常用的实例:WdatePicker下载 http:/ ...

  3. spring boot 启动数据库报错(Exception during pool initialization.)

    2018-06-27 14:12:28.804 ERROR 14312 --- [ restartedMain] com.zaxxer.hikari.pool.HikariPool : HikariP ...

  4. ionic ui 框架

    直接看着这写就行了 http://ionicframework.com/docs/components/

  5. switch语句相关

    Cannot switch on a value of type long. Only convertible int values, strings or enum variables are pe ...

  6. 使用 awk 过滤文本或文件中的字符串

    当我们在 Unix/Linux 下使用特定的命令从字符串或文件中读取或编辑文本时,我们经常需要过滤输出以得到感兴趣的部分.这时正则表达式就派上用场了. 什么是正则表达式? 正则表达式可以定义为代表若干 ...

  7. 160519、Oracle中将查询出的多条记录的某个字段拼接成一个字符串的方法

    with temp as( select 'China' nation ,'Guangzhou' city from dual union all select 'China' nation ,'Sh ...

  8. 8个Javascript小技巧

    1. 使用 + 字符可以转换成数字 比如要把一个字符串数字转换成数字,你可能会这样做: var one = '1'; var two = '2'; var numberOne = Number(one ...

  9. 挂载xfs磁盘

    # 磁盘初始化 [root@localhost ~]# fdisk /dev/sdb Welcome to fdisk (util-linux 2.23.2). Changes will remain ...

  10. UVA11426 GCD - Extreme (II)---欧拉函数的运用

    题目链接:http://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem& ...