大话"爪哇"泛型

时间  2019-11-05
标签 大话 爪哇 繁體版
原文   原文链接

  在某个不知名的方位有这么一个叫作爪哇的岛国，得天独厚的天然条件使得该国物产丰富，其中因为盛产著名的爪哇咖啡而闻名世界，每一年都吸引大批来自世界各地的游客前往观光学习，观光能够理解，学习这怎么个理解法，带着这个疑问咱们继续往下深刻，哔哔，开车！html

  颇有意思的是，在爪哇国中生活的当地居民都使用 Java 语言沟通交流，这种叫作 Java 的语言是由最初爪哇国第一代国王所创造出来的，由此逐渐完善并演变为文化文字、交流语言，一直传承至今。由于有了语言交流，也使得信息传达更加及时，这为该国生产咖啡豆(Java Bean) 的行业提供很是大的帮助，因此该国的咖啡豆出口需求量一直很大，也正所以爪哇岛的国旗是一杯热气腾腾的咖啡：java

泛型的出现

  任何样东西的推出都不是一下就完美的，玉石通过巧匠的雕琢后温润有方，上铺的室友任性辞职后，回家继承家产现有车有房，只留下我原地感慨：高级玩家！数组

  还在公元 JDK 1.4 年代的时候，那个时候尚未泛型的概念，当时的人们都是相似于下面交流：安全

public static void main(String[] args) {
    List list = new ArrayList();
    list.add("https://www.talkmoney.cn/");
    list.add(5);
    String str = (String)list.get(0);
    Integer num = (Integer)list.get(1);
}
复制代码

  首先能够看到的是声明了一个集合，而后往集合里放入不一样的数据，而且在取出数据的时候还要作强制类型转换，此外人们还会由于存入集合中第几个是什么类型的数据而烦恼，就会形成取出数据强转的时候形成转换异常ClassCastException，这就比如于加工商从种植园来的货车上卸下不一样品种的原料，致使最后所烘培加工的咖啡豆并非所须要的。多线程

  这种状况等到爪哇国第五代君主上任才有所改变，新任君主励精图治并针对此状况颁布泛型这条法规，通常的类和方法，只能使用具体的类型：要么是基本类型，要么是自定义的类。若是要编写能够应用于多种类型的代码，这种限制就会对代码的束缚就会很大，事实上，泛型是为了让编写的代码能够被不一样类型的对象重用，因而人们今后交流的方式又变为了如此：app

public static void main(String[] args) {
    List<String> list = new ArrayList();
    list.add("https://www.talkmoney.cn/");
    list.add("你们好，我是芦苇");
    String url = list.get(0);
    String name = list.get(1);
}
复制代码

  这时候建立集合并为其指定了 String 类型，也就是说如今只能往集合中存入 String 类型的数据，也正所以，在取出数据的时候也不须要再进行强制转换的操做，从而避免了类型转换异常的风险，而在爪哇国的"宪法"《Thinking in Java》中提出，泛型出现的缘由在于：ide

有许多缘由促成泛型的出现，其中最引人注意的一个缘由，就是为了建立容器类。学习

  仔细想一想，彷佛集合类库和泛型还真的有点配，这里以 Collection 接口为例：this

public interface Collection<E> extends Iterable<E> {

    Iterator<E> iterator();

    Object[] toArray();

    <T> T[] toArray(T[] a);
    
    boolean add(E e);

    boolean remove(Object o);

    boolean containsAll(Collection<?> c);

    boolean addAll(Collection<? extends E> c);

    boolean removeAll(Collection<?> c);
}   
复制代码

泛型的应用

  前面提到泛型是为了让编写的代码能够被不一样类型的对象重用，那么就须要给操做的数据类型指定参数，这种参数类型可使用在类、方法、集合、接口等，下面就分别来看看。url

泛型类

  假如如今咱们须要一个能够经过传入不一样类型数据的类，经过使用泛型能够这样来编写：

public class GenericClass<T> {
    private T item;
    
    public void setItem(T t) {
        this.item = t;
    }
    
    public void getItem(T t) {
        return this.item;
    }
}
复制代码

  咋一看能够发现泛型类和普通类差很少，区别在于类名后面多了个类型参数列表，尖括号内的 T 为指定的类型参数，这里不必定非得是 T，能够本身任意命名。指定参数后，能够看到类中的成员，方法及参数均可以使用这个参数类型，而且最后返回的都仍是这个指定的参数类型，来看它的使用：

public static void main(String[] args) {
    GenericClass<String> name = new GenericClass<>("芦苇科技");
    GenericClass<Integer> age = new GenericClass<>(5);
}
复制代码

泛型方法

  泛型方法顾名思义就是使用泛型的方法，它有本身的类型参数，一样它的参数也是在尖括号间，而且位于方法返回值以前，此外，泛型方法能够存在于泛型类或者普通类中，以下：

// 泛型类
public class GenericClass<T> {
    private T item;
    
    public void setItem(T t) {
        this.item = t;
    }
    // 只是用到了泛型并无声明类型参数，因此不要混淆此为泛型方法
    public void getItem(T t) {
        return this.item;
    }
    
    // 泛型方法
    public <T> void GenericMethod(T t) {
        System.out.println(t);
    }
}
复制代码

  这里须要注意的是，泛型方法中的类型 T 和泛型类中的类型 T 是两码事，虽然它们都是 T，但其实它们之间互相不影响，此外类型参数能够有多个。

泛型接口

  泛型接口的定义基本和泛型类的定义是差很少的，类型参数写在接口名后，以下：

public interface GenericInterface<T> {
    public void doSomething(T t);
}
复制代码

  在使用中，实现类在实现泛型接口时须要传入具体的参数类型，那么以后使用到泛型的地方都会被替换传入的参数类型，以下：

public class Generic implements GenericInterface<String> {
    @override
    public void doSomething(String s) {
     	......   
    }
}
复制代码

泛型通配符

  除去在前面介绍完的泛型类、方法等以外，泛型还有其余方面的应用，例若有时候但愿传入的类型参数有一个限定的范围内，这一点爪哇国显然也早就料到，解决方案即是泛型通配符，那么泛型通配符主要有如下三种类型：

  • 上界通配符 <? extends T>
  • 下界通配符 <? super T>
  • 无界通配符 <?>

  在了解通配符以前，首先咱们得要对类型信息有个基本的了解。

public class Coffee {}

// 卡布奇诺咖啡
public class Cappuccino extends Coffee {}

// 第一种建立方式
Cappuccino cappuccino = new Cappuccino();
// 第二种建立方式
Coffee cappuccino = new Cappuccino();
复制代码

  上面这个类中有一个 Coffee 类，Coffee 类是 Cappuccino 类的父类，往下即是两种建立类对象的方式，第一种方式很常见，建立 cappuccino 对象并指向 Cappuccino 类对象，这样在 JVM 编译时仍是运行时的类型信息都是 Cappuccino 类型。那么第二种方式呢，咱们使用 Coffee 类型的变量指向 Cappuccino 类型对象，这在 Java 的语法中称为向上转型，在 Java 中能够把子类对象赋值给父类对象。运行时类型信息可让咱们在程序运行时发现并使用类型信息，而全部的类型转换都是在运行时识别对象的类型，因此在编译时的类型是 Coffee 类型，而在运行时 JVM 经过初始化对象发现它指向 Cappuccino 类型对象，因此运行时它是 Cappuccino 类型。


上界通配符 <? extends T>

  大概理清了下类型信息后，前面咱们也提到过有时候但愿传入的类型参数有一个限定的范围内，那么在前面的基础上定义一个 Cup 类用来装载咖啡：

public class Cup<T> {
    private List<T> list;
    public void add(T t) {list.add(t);}
    public T get(int index) {return list.get(index);}
}
复制代码

  这里这个 Cup 类是一个泛型类，而且指明类型参数 T，表明着咱们能够传入任何类型，假如目前须要一个装咖啡的杯子，理论上既然是装咖啡的杯子，那么就能够装上卡布奇诺，由于卡布奇诺也是属于咖啡的一种啊对吧，以下：

Cup<Coffee> cup = new Cup<Cappuccino>();	// compiler error
复制代码

  然而咱们会发现代码在编译时会发生错误，虽然知道 Coffee 类和 Cappuccino 类存在继承关系，可是在泛型中是不支持这样的写法，解决办法就是经过上界通配符来处理：

Cup<? extends Coffee> cup = new Cup<Cappuccino>();
复制代码

  在类型参数列表中使用 extends 表示在泛型中必须是 Coffee 或者是其子类，固然在类型参数列表中还能够有多个参数，能够用逗号对它们进行隔开。经过上界通配符解决了这个问题，可是使用上界通配符会使得没法往其中存听任何对象，却能够从中取出对象。

Cup<? extends Coffee> cup = new Cup<Cappuccino>();
cup.add(new Cappuccino()); 			  // compiler error
Coffee coffee = cup.get(0);		          // compiler success
复制代码

  出现这种状况的缘由，咱们知道一个 Cup<? extends Coffee> 的引用，可能指向 Coffee 类对象，也能够指向其余 Coffee 类的子类对象，这样的话 JVM 在编译时并不能肯定具体是什么类型，而为了安全考虑，就直接一棒子打死。而从中取出数据，最后都能经过向上转型使用 Coffee 类型变量去引用它。因此，当咱们使用上界通配符 <? extends T> 的时候，须要注意的是不能往其中插入，可是能够读取；

下界通配符 <? super T>

  下界通配符 <? super T> 的特性则恰好与上界通配符 <? extends T> 相反，即只能往其中存入 T 或者其子类的数据，可是在读取的时候就会受到限制。

Cup<? super Cappuccino> cup = new Cup<Coffee>();         // compiler success
Cup<? super Cappuccino> cup = new Cup<Object>(); 	 // compiler success
Object object = cup.get(0);
复制代码

  对于 cup 来讲，它指向的具体类型能够是 Cappuccino 类的任何父类，虽然没法知道具体是哪一个类型，可是它均可以转化为 T 类型，因此能够往其中插入 T 及其子类的数据，而在读取方面，由于里面存储的都是T 及其基类，没法转型为任何一种类型，只有经过 Object 基类去取出数据。

无界通配符 <?>

  若是单独使用 则使用的是无界通配符，若是不肯定实际要操做的类型参数，则可使用该通配符，它能够持有任何类型，这里须要注意的是，咱们很容易将 和 搞混，例如 List 和 List 咋看之下彷佛非常相像，实际上却不是这样的，List 是一个未知类型的 List，而 List 则是任意类型的 List，咱们能够将 List 赋值给 List<?>，却不能把 List 赋值给 List，要搞清楚这一点：

List<Object> objectList = new ArrayList<>();
List<?> anyTypeList;
List<String> stringList = new ArrayList<>();

anyTypeList = stringList;	       // compiler success
objectList = (List<Object>)stringList; // compiler error
复制代码

通配符小结

  经过前面的了解，无界通配符 <?> 用于表示不肯定限定范围的场景下，而对于使用上界通配符 <? extends T> 和下界通配符 <? super T> 也知道它们的使用和受限制的地方：

  • 上界通配符 <? extends T> 不能插入存储数据，却能够读取数据，适合须要内容读取的场景；
  • 下界通配符 <? super T> 则能够插入 T 类型及其子类对象，而只能经过 Object 变量去取出数据，适合须要内容插入的场景；

  实际上，这种状况又被叫作 PECS 原则，PECS 的全称是 Producer Extends Consumer Super。Producer Extends 说明的是当须要获取内容资源去生产时，此时的场景角色是生产者，可使用上界通配符 <? extends T> 更好地读取数据；Consumer Super 则指的是当咱们须要插入内容资源以待消费，此时的场景角色是消费者，可使用下界通配符 <? super T> 更好地插入数据。具体的选择能够根据本身的实际场景须要灵活选择。说到生产者消费者，感受又回到初识多线程那会儿，时间就这样悄悄地溜走，捉也捉不住。

泛型的神秘之处

关于泛型机制

  在金庸老爷子描绘的江湖世界中，里面有种武功绝学叫作乾坤大挪移，只要习得此功能够直接施展对方武功，哪怕是现学现用都过之而不及，听起来泛型彷佛也差很少。那么先从一个例子提及：

public class Demo {
    public static void main(String[] args) {
        ArrayList<String> a = new ArrayList<String>();
        ArrayList<Integer> b = new ArrayList<Integer>();
        System.out.println(a.getclass() == b.getclass());
    }
}
// 运行结果：true
复制代码

  尽管这是两个不一样类型的集合数组，当获取它们的类信息并比较的时候，此时的二者之间的类型居然是同样的，究其缘由这是 Java 泛型擦除的机制，首先须要明白的是，泛型是体如今编译的时候实现，以后在生成的字节码文件和运行时是不包含泛型信息的，因此类型信息是会被擦除掉的，只留下原始类型，这个过程就是泛型擦除的机制，之因此擦除是为了兼容以前原有的代码。此外，关于原始类型下面再展开叙述。

  上面提到泛型被擦除后只保留原始类型，那么这个原始类型啥东东，以下：

// 擦除前
public class GenericClass<T> {
    private T data;
    
    public T getData() {return data;}
    ......
}

// 擦除后
public class GenericClass {
    private Object data;
    
    public Object getData() {return data;}
    ......
}
复制代码

  对于没有指定界限类型参数，在被类型擦除以后会被替换为 Object，这是相对于无界类型参数而言，如上述所言，若是没有指定限制范围，那么类型参数就会被替换为 Object，那若是要让类型限定在一个范围内的状况呢？

// 擦除前
public class GenericClass<T extends Serializable> {
  	private T data;
    public T getData() {return data;}
    ......
}

// 擦除后
public class GenericClass {
    private Serializable data;
    public Serializable getData() {return data;}
    ......
}
复制代码

  那么此时的状况是有界类型参数，类型擦除后会替换为指定的边界，固然这里的边界能够指定多个，若是在有多个边界的状况下，那么类型参数也只是会擦除第一个边界。

泛型的本质

  说到这里，咱们可能就会存在这样一个疑问，既然说泛型在类编译的时候会被擦除，那么在运行时是如何作到插入读取类型一致的呢？换句话来讲就是，泛型类型参数被擦除为原始类型 Object，那么按理来讲是能够插入其余类型的数据的啊！

  事实上，JVM 虽然在对类进行编译的时候将类型参数进行擦除，可是它会保证使用到泛型类型参数的一致性。咱们知道，在类还处于编译阶段的时候，此时的类型参数还能够获取的到，编译器能够作类型检查，举例来讲就是，一个 ArrayList 被声明为 Integer 的时候，当往该 ArrayList 中插入数据的时候会对其进行判断，以此保证数据类型的一致性。而当类型参数被擦除后，为了可以保证从中读取数据的类型是原来指定的类型参数，JVM 默默地帮咱们进行类型转换，以此将类型参数还原成咱们指定的那个它~

泛型的限制

  因为 Java 泛型擦除机制，指定的类型参数会被擦除，因此对于如下的一些操做将是不容许的：

  • 不能使用类型参数进行建立实例；
  • 不能使用类型参数进行 instanceof;
public class GenericClass<T> {
    public static void method(Object obj) {
        if (obj instanceof T) { // compiler error
            ......
        }
        T t = new T(); // compiler error
    }
}
复制代码
  • 泛型指定的类型参数不能是基本类型
ArrayList<int> list = new ArrayList<int>(); // compiler error
/** * 可使用基本数据类型的包装类 */
ArrayList<Integer> list = new ArrayList<Integer>(); // compiler success
复制代码
  • 不能建立类型参数的数组
ArrayList<Integer>[] list = new ArrayList<Integer>(3);
复制代码

结语

  能够看到，爪哇国为了能让国民安居乐业，也是下了一番苦心，这些年来随着“咖啡市场"的供不该求，不少人也都加入了进来，在文章的开头中也提到，每一年都吸引大批来自世界各地的游客前往观光学习，将来到底怎么样谁也不知道，只是不少时候就像一座围城，有的人出来，有的人进去。用他们的一句话来讲：”唉啥，混口饭吃！“。

  到这里，本文已经进入尾声，关于泛型这一方面还有许多未能详细记录，但愿也能在这里起到个抛砖引玉的做用，因为本人水平有限还请批评指正。

参考：


内推信息

  • 咱们正在招募小伙伴，有兴趣的小伙伴能够把简历发到 app@talkmoney.cn，备注：来自掘金社区
  • 详情能够戳这里--> 广州芦苇信息科技
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程