看完后让你成为武松，手把手教你打死Java中的纸老虎

泛型，其实算是Java当中比较难的语法了，很多人一开始都对其一知半解，也很害怕阅读带泛型的源码，虽然看起来语法很难，但当你理解后会觉得很简单，其实只是一个纸老虎罢了。下面，我将会用非常简单易懂的方式带你去理解它，相信你在认真看完后会有非常大的收获，从此不会再畏惧它!

[[422931]]

一. 泛型的定义

这里大家可以不必去看网上的有些定义，因为相对于比较学术化，只需记住泛型可以在程序设计中指定某种类型，让程序的设计更加规范化即可

二. 为什么要用到泛型

了解到了泛型是什么后，那我们来讨论讨论为什么要用泛型这个语法，这个语法到底是干什么的?别急，下面，我先给大家举一个例子： 

 
 
 
 
    
  
  
  
  
  1. class Stack { 
    2.   
  
  
  
  2.     public Object[] objects; 
    3.   
  
  
  
  3.     public int top; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     public Stack() { 
    6.   
  
  
  
  6.         this.objects =new Object[10]; 
    7.   
  
  
  
  7.     } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     public void push(Object obj) { 
    10.   
  
  
  
  10.         objects[this.top++] = obj; 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.     public Object get() { 
    14.   
  
  
  
  14.         return objects[this.top-1]; 
    15.   
  
  
  
  15.     } 
    16.   
  
  
  
  16. } 
    17.

大家可以看看这是在干什么呢?这是我们自己写了一个栈，然后将栈里的数组类型设置成Object类型，这样的话这个栈里任意类型的数据都可以存放了(Object类是任何类的父类，不管插入什么类型的数据，都可以发生向上转型)

下面，我们来测试一下： 

 
 
 
 
    
  
  
  
  
  1. public class Test { 
    2.   
  
  
  
  2.     public static void main(String[] args) { 
    3.   
  
  
  
  3.         Stack stack=new Stack(); 
    4.   
  
  
  
  4.         stack.push(1); 
    5.   
  
  
  
  5.         stack.push(2); 
    6.   
  
  
  
  6.         stack.push("123"); 
    7.   
  
  
  
  7.         String str=(String)stack.get(); 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9. } 
    10.

可以看到，我们可以向自己写的栈里放入整形以及字符串等等任何类型的数据，但注意一下取出数据的时候要进行强制类型转换

以上这样写，可以向栈里存放任何类型的数据，比较通用，其优点也可以变成缺点，正因为太通用了，使代码的规范性降低，看起来比较凌乱，这时候，我们可以考虑使用泛型，这样可以在类中或者Java集合中存放特定的数据(使用Java集合时，一般都要用到泛型，而自定义的类型中可以使用泛型也可以不使用)

三. 泛型的写法

以自定义的类型为例，写法为在类名后面加上尖括号，里面写上一个字母(注意，此处写任何字母都可以，只起到一个标记这个类为泛型类的作用)

 
 
 
 
    
  
  
  
  
  1. class Stack 
    2.

而在new对象时，以栈里只能存放整形为例，前面的尖括号必须写基本数据类型对应的包装类，而后面的尖括号可以不用写，示例如下：

 
 
 
 
    
  
  
  
  
  1. Stack stack = new Stack<>(); 
    2.

补一下Java中的基本数据类型与对应的包装类：

因此，我们前面写的自定义的栈可以写成以下形式(以存放整形为例)： 

 
 
 
 
    
  
  
  
  
  1. class Stack { 
    2.   
  
  
  
  2.     public T[] objects; 
    3.   
  
  
  
  3.     public int top; 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.     public Stack() { 
    6.   
  
  
  
  6.         this.objects = (T[])new Object[10]; 
    7.   
  
  
  
  7.     } 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9.     public void push(T obj) { 
    10.   
  
  
  
  10.         objects[this.top++] = obj; 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12.  
    13.   
  
  
  
  13.     public T get() { 
    14.   
  
  
  
  14.         return objects[this.top-1]; 
    15.   
  
  
  
  15.     } 
    16.   
  
  
  
  16. } 
    17.   
  
  
  
  17.  Stack stack = new Stack<>(); 
    18.   
  
  
  
  18.         stack.push(1); 
    19.   
  
  
  
  19.         stack.push(2); 
    20.   
  
  
  
  20.         int ret = stack.get(); 
    21.   
  
  
  
  21.         System.out.println(ret); 
    22.

特别注意此处：public Stack() { this.objects = (T[])new Object[10]; }

这里不能写成this.objects=new T[10];

原因：

  1. 不能new泛型类型的数组
  2. 也可理解为泛型是先检查后编译的，如果new泛型类型的数组的话，编译器检查时并不知道T是什么类型的，因此会报错。而编译的时候才会进行擦除机制，都会将其转换为Object类型
  3. 正因为有这个擦除机制，这里才能进行数组整体强制类型转换(一般数组不能整体进行强制类型转换)，因为泛型只是在编译的时候起作用，而实际运行时都会被擦除成Object类型，即实际运行时是没有泛型这个概念的，也即实际运行时类型都是一样的，所以T本质上是object类型的，所以此代码等价于不进行强制类型转换!!!
  4. 而直接指定泛型的代码(不是T) 比如：Stack和Stack都是在运行时直接把尖括号里的类型擦掉了，可以看到直接打印的结果(并没有打印出类型)：

此处注意多理解理解

四. 泛型的使用实例

1. 求最大值

以上就是泛型的一个重要知识点了，但光看是不够的，还是得通过例子让大家有一个更为深入的理解，比如，如何写一个泛型类来求数组的最大值呢?

基本的框架大概是这样的：(没看懂的小可爱好好看看上面讲的内容哦) 

 
 
 
 
    
  
  
  
  
  1. class Algorithm> { 
    2.   
  
  
  
  2.     public T findMax(T[] array) { 
    3.   
  
  
  
  3.         T max = array[0]; 
    4.   
  
  
  
  4.         for (int i = 1; i < array.length; i++) { 
    5.   
  
  
  
  5.             if(max < array[i]) { 
    6.   
  
  
  
  6.                 max = array[i]; 
    7.   
  
  
  
  7.             } 
    8.   
  
  
  
  8.         } 
    9.   
  
  
  
  9.         return max; 
    10.   
  
  
  
  10.     } 
    11.   
  
  
  
  11. } 
    12.

但是此代码if(max < array[i])会报错，为什么呢?因为将来给T传的值一定是一个引用类型，引用类型不能直接比较大于或者小于的，是要用Comparable或Comparator接口里的方法比较的，因为泛型在编译的时候会被擦除成Object类型，但Object类本身并没有实现Comparable或Comparator接口，所以我们要控制其不要擦除到Object类，所以要给泛型指定一个边界

具体写法如下： 

 
 
 
 
    
  
  
  
  
  1. class Algorithm> { 
    2.   
  
  
  
  2.     public T findMax(T[] array) { 
    3.   
  
  
  
  3.         T max = array[0]; 
    4.   
  
  
  
  4.         for (int i = 1; i < array.length; i++) { 
    5.   
  
  
  
  5.             //max < array[i] 
    6.   
  
  
  
  6.             if(max.compareTo(array[i]) < 0) { 
    7.   
  
  
  
  7.                 max = array[i]; 
    8.   
  
  
  
  8.             } 
    9.   
  
  
  
  9.         } 
    10.   
  
  
  
  10.         return max; 
    11.   
  
  
  
  11.     } 
    12.   
  
  
  
  12. } 
    13.   
  
  
  
  13.  
    14.   
  
  
  
  14. class Algorithm> 
    15.

注意，extends叫做上界，此代码代表的意思为T这个泛型类会擦除到实现了Comparable接口的地方，换句话说，这个T类型一定是实现了Comparable接口的

同理：这个代码public class MyArrayList { ... }代表E为Number的子类或Number本身

下面让我们来用一下： 

 
 
 
 
    
  
  
  
  
  1. Algorithm algorithm1 = new Algorithm<>(); 
    2.   
  
  
  
  2.        Integer[] integers = {1,2,13,4,5}; 
    3.   
  
  
  
  3.        Integer ret = algorithm1.findMax(integers); 
    4.   
  
  
  
  4.        System.out.println(ret); 
    5.

运行结果如下：

[[422934]]

成功了!

2. 优化

经过上面的努力，我们已经写出了一个泛型类来求一个数组的最大值了，但是，上面的例子是一个整形数组，那么我们能不能在数组里存放别的类型去比较呢?答案是可以的，但是我们还得去new一个对象，例如：Algorithm algorithm2 = new Algorithm<>();这样很麻烦。但是我们可以将求最大值的方法设置成静态的class Algorithm2 ,因为是静态的方法，不需要new对象，所以就没有在new对象时指定泛型的过程了，所以没必要给方法后加尖括号，但是去掉之后，代码又会被错：

我们可以这样修改： 

 
 
 
 
    
  
  
  
  
  1. class Algorithm2 { 
    2.   
  
  
  
  2.     public static> T findMax(T[] array) { 
    3.   
  
  
  
  3.         T max = array[0]; 
    4.   
  
  
  
  4.         for (int i = 1; i < array.length; i++) { 
    5.   
  
  
  
  5.             if(max.compareTo(array[i]) < 0) { 
    6.   
  
  
  
  6.                 max = array[i]; 
    7.   
  
  
  
  7.             } 
    8.   
  
  
  
  8.         } 
    9.   
  
  
  
  9.         return max; 
    10.   
  
  
  
  10.     } 
    11.   
  
  
  
  11. } 
    12.

此方法public static> T findMax(T[] array){}叫做泛型方法

下面继续带大家来用一下： 

 
 
 
 
    
  
  
  
  
  1. public static void main(String[] args) { 
    2.   
  
  
  
  2.         Integer[] integers = {1,2,13,4,5}; 
    3.   
  
  
  
  3.         //会根据形参的类型推导出整个泛型的类型参数 
    4.   
  
  
  
  4.         Integer ret = Algorithm2.findMax(integers); 
    5.   
  
  
  
  5.         System.out.println(ret); 
    6.   
  
  
  
  6.         Integer ret2 = Algorithm2.findMax(integers); 
    7.   
  
  
  
  7.         System.out.println(ret2); 
    8.   
  
  
  
  8.     } 
    9.

注意，ret1写法和ret2写法是一样的，都可以

打印结果如下：

五. 通配符

1. 基本写法

通配符也是泛型的一种，下面我们来写一个泛型方法来打印集合中的元素。 

 
 
 
 
    
  
  
  
  
  1. class Test { 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     public static void print(ArrayList list) { 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5.         for (T t : list) { 
    6.   
  
  
  
  6.             System.out.println(t); 
    7.   
  
  
  
  7.         } 
    8.   
  
  
  
  8.     } 
    9.

这个写法很简单，上文都讲过了，那么让我们来试着用一下吧： 

 
 
 
 
    
  
  
  
  
  1. public static void main(String[] args) { 
    2.   
  
  
  
  2.         ArrayList list = new ArrayList<>(); 
    3.   
  
  
  
  3.         list.add(1); 
    4.   
  
  
  
  4.         list.add(2); 
    5.   
  
  
  
  5.         list.add(3); 
    6.   
  
  
  
  6.         Test.print(list); 
    7.   
  
  
  
  7.     } 
    8.

打印的结果如下：

除了以上这种写法，我们还可以将其改成通配符的写法，先给大家上代码： 

 
 
 
 
    
  
  
  
  
  1. //？代表通配符  擦除机制  Object 
    2.   
  
  
  
  2.     public static void print2(ArrayList list) { 
    3.   
  
  
  
  3.         for (Object t : list) { 
    4.   
  
  
  
  4.             System.out.println(t); 
    5.   
  
  
  
  5.         } 
    6.   
  
  
  
  6.     } 
    7.   
  
  
  
  7. } 
    8.

此处for (Object t : list)必须这样写，因为通配符也是有擦除机制的，会在编译器编程Object类型。

2. 上界

  • 语法：
  • 示例： 
 
 
 
 
    
  
  
  
  
  1. public static void printAll(MyArrayList list) {  
    2.   
  
  
  
  2. ...  
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. xxxxxxxxxxbr public static void printAll(MyArrayList list) {br...br } 
    6.

代表可以传入类型实参是 Number 子类的任意类型的 MyArrayList所以以下调用都是正确的： 

 
 
 
 
    
  
  
  
  
  1. printAll(new MyArrayList());  
    2.   
  
  
  
  2. printAll(new MyArrayList());  
    3.   
  
  
  
  3. printAll(new MyArrayList()); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. xxxxxxxxxxbr printAll(new MyArrayList());brprintAll(new MyArrayList());brprintAll(new MyArrayList()); 
    6.

以下调用都是错误的： 

 
 
 
 
    
  
  
  
  
  1. printAll(new MyArrayList());  
    2.   
  
  
  
  2. printAll(new MyArrayList ()); 
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4. xxxxxxxxxxbr printAll(new MyArrayList());brprintAll(new MyArrayList()); 
    5.

3. 下界

下界和上界的用法很类似

  • 语法：
  • 示例： 
 
 
 
 
    
  
  
  
  
  1. public static void printAll(MyArrayList list) {  
    2.   
  
  
  
  2. ...  
    3.   
  
  
  
  3. } 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. xxxxxxxxxxbr public static void printAll(MyArrayList list) {br...br} 
    6.

代表可以传入类型实参是 Integer 父类的任意类型的 MyArrayList所以以下调用是正确的： 

 
 
 
 
    
  
  
  
  
  1. printAll(new MyArrayList());  
    2.   
  
  
  
  2. printAll(new MyArrayList());  
    3.   
  
  
  
  3. printAll(new MyArrayList()); 
    4.   
  
  
  
  4.  
    5.   
  
  
  
  5. xxxxxxxxxxbr printAll(new MyArrayList());brprintAll(new MyArrayList());brprintAll(new MyArrayList()); 
    6.

以下调用是错误的： 

 
 
 
 
    
  
  
  
  
  1. printAll(new MyArrayList());  
    2.   
  
  
  
  2. printAll(new MyArrayList()); 
    3.   
  
  
  
  3.  
    4.   
  
  
  
  4. xxxxxxxxxxbr printAll(new MyArrayList());brprintAll(new MyArrayList()); 
    5.

六. 泛型的限制 

学习完后，我们应该注意泛型使用过程中以下一些限制：

  • 泛型类型参数不支持基本数据类型

  • 无法实例化泛型类型的对象

  • 无法使用泛型类型声明静态的属性

  • 无法使用 instanceof 判断带类型参数的泛型类型(因为被擦除机制擦除了)

  • 无法创建泛型类数组

  • 无法 create、catch、throw 一个泛型类异常(异常不支持泛型)

  • 泛型类型不是形参一部分，无法重载

好啦，本次泛型知识点的分享就先告一段落了，整理不易，但如果能帮到大家很开心了。也希望大家多理解理解，不论是刚开始学习还是复习，都值得仔细揣摩哦!一起加油吧!

 

 

分享题目：看完后让你成为武松，手把手教你打死Java中的纸老虎
浏览路径：http://www.shufengxianlan.com/qtweb/news38/326288.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

企业建站知识

各行业网站

德阳服务器托管　　 　网站营销　　 　php空间　　 　鳄鱼养殖　　 　app软件开发公司　　 　成都小程序　　 　成都广告招牌　　 　德阳网站建设　　 　德阳东方电机技改　　 　航空文化传媒　　 　添翼二手车鉴定评估　　 　成都app制作　　 　Android开发　　 　新都网站建设　　 　成都移动主机托管　　 　网上商城管理系统　　 　简阳服务器托管　　 　成都做网站　　 　成都网站排名　　 　卖友情链接