IT培训>编程语言教程

    编程语言你必须知道的知识

    作者:编码是个技术活更新于： 2021-04-26 14:25:23

    大神带你学编程，欢迎选课

    java泛型你必须知道的知识。编程语言原本是被设计成专门使用在计算机上的，但它们也可以用来定义算法或者数据结构。正是因为如此，程序员才会试图使程序代码更容易阅读。

    Java 泛型（generics）是 JDk 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

    编程语言你必须知道的知识_java_javascript_java在线高清_课课家

     一 什么是泛型

    Java 泛型(generics)是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

    简单理解就是：泛型指定编译时的类型，减少运行时由于对象类型不匹配引发的异常。其主要用途是提高我们的代码的复用率。

    我们Java标准库中的ArrayList就是泛型使用的典型应用：

    1. public class ArrayList extends AbstractList implements List, RandomAccess, Cloneable, java.io.Serializable { 
    2.         
    3.       ...... 
    4.  
    5.     public ArrayList(Collection c) { 
    6.         elementData = c.toArray(); 
    7.         if ((size = elementData.length) != 0) { 
    8.             // c.toArray might (incorrectly) not return Object[] (see 6260652) 
    9.             if (elementData.getClass() != Object[].class) 
    10.                 elementData = Arrays.copyOf(elementData, size, Object[].class); 
    11.         } else { 
    12.             // replace with empty array. 
    13.             this.elementData = EMPTY_ELEMENTDATA; 
    14.         } 
    15.     } 
    16.  
    17.     public void sort(Comparator c) { 
    18.         final int expectedModCount = modCount; 
    19.         Arrays.sort((E[]) elementData, 0, size, c); 
    20.         if (modCount != expectedModCount) { 
    21.             throw new ConcurrentModificationException(); 
    22.         } 
    23.         modCount++; 
    24.     } 
    25.     
    26.   ..... 
    27.  
    28.     public E get(int index) { 
    29.         rangeCheck(index); 
    30.  
    31.         return elementData(index); 
    32.     } 
    33.  
    34.     public boolean add(E e) { 
    35.         ensureCapacityInternal(size + 1);  // Increments modCount!! 
    36.         elementData[size++] = e; 
    37.         return true; 
    38.     } 
    39.  
    40. } 
    •  源码中，ArrayList中的E称为类型参数变量，而整个ArrayList我们称为泛型类型。 我们可以指定除基本类型之外的任何类型，如：ArrayList。
    • 源码中Collection 中? 通配符类型 表示类型的上界，表示参数化类型的可能是T 或是 T的子类。
    • 源码中Comparator 表示类型下界(Java Core中叫超类型限定)，表示参数化类型是此类型的超类型(父类型)，直至Object。

    二 extends和super通配符

    在定义泛型类型Generic的时候，也可以使用extends通配符来限定T的类型：

     

    1. public class Generic { ... } 

    现在，我们只能定义：

    1. Generic p1 = null; 
    2. Generic<Integer> p2 = new Generic<>(1, 2); 
    3. Generic<Double> p3 = null; 

     

    因为Number、Integer和Double都符合。

    非Number类型将无法通过编译：

    1. Generic p1 = null; // compile error! 
    2. Generic p2 = null; // compile error! 

      因为String、Object都不符合，因为它们不是Number类型或Number的子类。

      我们看一个例子：

      1. public class Test { 
      2.  
      3.     static class Food { 
      4.  
      5.     } 
      6.  
      7.     static class Fruit extends Food { 
      8.     } 
      9.  
      10.     static class Apple extends Fruit { 
      11.     } 
      12.  
      13.     static class Orange extends Fruit { 
      14.     } 
      15.  
      16.     public void testExtend() { 
      17.         List list = new ArrayList(); 
      18.  
      19.         //无法安全添加任何具有实际意义的元素,报错,extends为上界通配符,只能取值,不能放. 
      20.         //因为Fruit的子类不只有Apple还有Orange,这里不能确定具体的泛型到底是Apple还是Orange，所以放入任何一种类型都会报错 
      21.  
      22.         //list.add(new Apple()); 
      23.         //list.add(new Orange()); 
      24.  
      25.         //可以添加null，因为null可以表示任何类型 
      26.         list.add(null); 
      27.  
      28.         //可以正常获取，用java多态 
      29.         Food foot = list.get(0); 
      30.         Apple apple = (Apple) list.get(0); 
      31.     } 
      32.  
      33.     public void testSuper() { 
      34.         List list = new ArrayList(); 
      35.  
      36.         //super为下界通配符，可以存放元素，但是也只能存放当前类或者子类的实例，以当前的例子来讲， 
      37.         list.add(new Fruit()); 
      38.         list.add(new Apple()); 
      39.  
      40.         //无法确定Fruit的父类是否只有Food一个(Object是超级父类) 
      41.         //因此放入Food的实例编译不通过，只能放自己的实例 或者根据java多态的特性放子类实例 
      42.         //list.add(new Food()); 
      43.         //List list2 = new ArrayList(); 
      44.         //Fruit fruit = list.get(0); //不能确定返回类型 
      45.  
      46.     } 
      47.  
      48. } 

      在testExtend方法中，因为泛型中用的是extends，在向list中存放元素的时候，我们并不能确定List中的元素的具体类型，即可能是Apple也可能是Orange。因此调用add方法时，不论传入new Apple()还是new Orange()，都会出现编译错误。

      理解了extends之后，再看super就很容易理解了，即我们不能确定testSuper方法的参数中的泛型是Fruit的哪个父类，因此在调用get方法时只能返回Object类型。结合extends可见，在获取泛型元素时，使用extends获取到的是泛型中的上边界的类型(本例子中为Fruit),范围更小。

      总结：

      • 在使用泛型时，存取元素时用super。
      • 获取元素时，用extends。

      有了上面的结论我们看下Java标准库的Collections类定义的copy()方法，这个copy()方法的定义就完美地展示了extends和super的意图：

      • copy()方法内部不会读取dest，因为不能调用dest.get()来获取T的引用;
      • copy()方法内部也不会修改src，因为不能调用src.add(T)。
      1. public class Collections { 
      2.     // 把src的每个元素复制到dest中: 
      3.     public static  void copy(List dest, List src) { 
      4.         for (int i=0; isize(); i++) { 
      5.             T t = src.get(i); 
      6.             dest.add(t); 
      7.         } 
      8.     } 
      9. } 

      三 泛型擦除

      Java的泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，正确理解泛型概念的首要前提是理解类型擦除。Java的泛型基本上都是在编译器这个层次上实现的，在生成的字节码中是不包含泛型中的类型信息的，使用泛型的时候加上类型参数，在编译器编译的时候会去掉，这个过程成为类型擦除

      我们看一个示例：

      1. public class Test2 { 
      2.  
      3.     public static void main(String[] args) { 
      4.         Map map = new HashMap<>(); 
      5.         Animal animal = new Animal(); 
      6.         animal.setVegetarian(true); 
      7.         animal.setEats("fish"); 
      8.         map.put("cat", animal); 
      9.  
      10.         String json = new Gson().toJson(map); 
      11.         System.out.println(json); 
      12.  
      13.         Map jsonToMap = fromJson(json); 
      14.         System.out.println(jsonToMap); 
      15.  
      16.         Animal animal1 = jsonToMap.get("cat"); 
      17.         System.out.println(animal1.getEats()); 
      18.     } 
      19.  
      20.     public static  T fromJson(String str) { 
      21.         return new Gson().fromJson(str, new TypeToken() { 
      22.         }.getType()); 
      23.     } 
      24.  
      25. } 

      上的代码运行会提示如下异常：

      1. Exception in thread "main" java.lang.ClassCastException: com.google.gson.internal.LinkedTreeMap cannot be cast to com.uaf.rabbitmq.producer.Animal 
      2.     at com.uaf.rabbitmq.producer.Test2.main(Test2.java:30) 

      异常原因主要是这句：new Gson().fromJson(str, new TypeToken() {}.getType());

      这句在实际执行的时候，List中的T并未传入实际的泛型参数，导致Gson按照LinkedTreeMap来解析JSON，以致发生了错误;这就是一个在编译期泛型类型擦除所导致的问题;

      解决这个问题我们需要修改fromJson方法

      1. public class Test2 { 
      2.  
      3.     public static void main(String[] args) { 
      4.         Map map = new HashMap<>(); 
      5.         Animal animal = new Animal(); 
      6.         animal.setVegetarian(true); 
      7.         animal.setEats("fish"); 
      8.         map.put("cat", animal); 
      9.  
      10.         String json = new Gson().toJson(map); 
      11.         System.out.println(json); 
      12.  
      13.         Map jsonToMap = fromJson(json,  
      14.         new TypeToken>() {}.getType()); 
      15.         System.out.println(jsonToMap); 
      16.  
      17.         Animal animal1 = jsonToMap.get("cat"); 
      18.         System.out.println(animal1.getEats()); 
      19.  
      20.     } 
      21.  
      22.     public static  T fromJson(String str, Type type) { 
      23.         return new Gson().fromJson(str, type); 
      24.     } 
      25.  
      26. } 

      在Gson中提供了TypeToken解决泛型运行时类型擦除问题，TypeToken 这个类来帮助我们捕获像Map这样的泛型信息。上文创建了一个匿名内部类，这样Java编译器就会把泛型信息编译到这个匿名内部类里，然后在运行时就可以被getType()方法用反射API提取到。

      编程语言（programming language）是一种被标准化的交流技巧，用来向计算机发出指令，定义计算机程序，让程序员能够准确地定义计算机所需要使用的数据，并精确地定义在不同情况下所应当采取的行动的一种计算机语言。 编程语言可以分成机器语言、汇编语言、高级语言三大类。计算机领域已发明了上千不同的编程语言，而且每年仍有新的编程语言诞生。

      标签： javajavascriptjava在线高清

      上一篇：编程语言寻找二叉树的下一个节点

      下一篇：编程语言RestSharp.net REST/HTTP 工具库

      为您推荐

      咨询电话：020-32643462　(联系方式)

      广州挪贤计算机科技有限公司 版权所有

      © 2013-2023 课课家 kokojia.com

      课课家教育

      首页 课程分类 课程套餐 线路图 读书 资讯 商城 博客 论坛 我的课程 帐户中心 购物车

      未登录