首页 > > 程序设计 > Java技术 >

Java数据结构与算法分析-第一章（引论）-Java中…

2018-06-18 01:27:37来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

一、为什么需要使用范型？

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

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

　　说明一下：在没有范型或者不使用范型的时候，下面给出一个假设：

　　　　　Person类的构造器：public Person(Object o){this.o=o}

　　　我们编码的时候实例化一个类的实例（含参数）：Person  p1=new Person(1），　Person  p1=new Person("小风微凉"）;

　　   那么问题来了，我们知道传入的参数被传递给了Person的o属性，由于传入的类型都是Object的子类型，所以编译的时候是没有问题的，此时看不到错误，但是我们  并不知道这个属性o会做如何的处理，这个处理就会对数据的类型有着严格的要求了，当然处理的时候也不会编译报错，毕竟是Object类型，但是会在jvm调用执行的时候报错：ClassCastException

    所以：使用范型的好处之一就是：把报错的时机，从运行时提前到了编译时，这样更有利于我们编码。

　　　　并且，范型具有自动装箱拆箱的功能。

二、举个例子分析一下

 不使用范型的例子就太多了，这里我直接使用范型，在使用中说明一下我的发现。

（1）定义一个范型接口：GenericInterface<T>：这种用法，在前一篇介绍ArrayList源码的时候就多次出现过。

 1 package com.xfwl.generics;
 2 /**
 3  * 数据结构与算法分析：第一章
 4  * @function  泛型结构（jre1.5及以上）
 5  * @author 小风微凉
 6  * @time  2018-5-6 下午12:51:45
 7  * @param <T>
 8  */
 9 public interface GenericInterface<T> {
10     //定义一个属性
11     public static int INT_1=1;
12     /**
13      * 接口中定义的范型方法
14      * @param t 传入参数范型类型T
15      * @return 返回范型类型T
16      */
17     public T fun_1(T t);
18 }

  说明一下：

　　在定义这个范型接口的时候，我发现定义属性的时候：不能使用范型！ 

　　原因：因为接口中的属性的默认修饰符为：public static  ,而Java的泛型是擦除机制，所以不能被static修饰为共有部分，因此编译不会通过。

（2）定义一个范型类：GenericClass<T,E>

 1 package com.xfwl.generics;
 2 /**
 3  * 数据结构与算法分析：第一章
 4  * @function  泛型类（jre1.5及以上）
 5  * @author 小风微凉
 6  * @time  2018-5-6 下午12:39:08
 7  */
 8 @SuppressWarnings("unchecked")
 9 public class GenericClass<T,E> implements GenericInterface<T> {
10     private T att1;//属性1
11     public String att2;//属性2
12     private GenericClass generic=null;
13     public GenericClass(T t){
14         this.att1=t;
15     }
16     //单例模式-懒汉式:范型不能用于static修饰的属性或方法中
17     public GenericClass getSingleInstence(T t){
18         if(generic==null){
19             generic=new GenericClass<T,E>(t);
20         }
21         return generic;
22     }
23     /**
24      * 接口中实现方法
25      */
26     public T fun_1(T t) {
27         System.out.println("fun_1()输出："+t);
28         return null;
29     }
30     /**
31      * 当前类中的方法
32      * @param e    传递过来的类型
33      * @return    返回范型E
34      */
35     public E fun_2(E e){
36         System.out.println("fun_2()输出："+e);
37         return e;
38     }
39 }

 说明一下：

　　定义范型类的时候，可以直接实现范型接口：implements GenericInterface<T>，而泛型类中的范型也可允许为多个即： GenericClass<T,E>，但是需要注意的一点是：范型类中的范型必须包含范型接口中的范型，原因很简单，既然实现了接口，就必须重写接口里面的方法，而这些方法就使用了范型接口中的范型，所以就这样喽！同样的，范型类中不可以使用static去修饰范型属性。

（3）范型的使用

定义了一个使用范型的类：

 1 package com.xfwl.generics;
 2 public class Test {
 3     /**
 4      * @param args
 5      */
 6     public static void main(String[] args) {
 7         //不使用范型
 8         GenericClass g_4=new GenericClass("type_String");
 9         //使用范型：三种方法均可
10         GenericClass<String, Integer> g_1=new GenericClass<String, Integer>("type_String");
11         GenericClass<String, Integer> g_2=new GenericClass("type_String");
12         GenericClass<String, Integer> g_3=new GenericClass<>("type_String");//jre1.7及以上:菱形运算符
13         //开始调用方法
14         g_1.fun_1("g_1_1");//jre1.5及以上
15         g_1.fun_2(1);
16         
17         g_2.fun_1("g_2_1");//jre1.5及以上
18         g_2.fun_2(2);
19         
20         g_3.fun_1("g_3_1");//jre1.7及以上
21         g_3.fun_2(3);
22         
23     }
24 }

 先运行一下，看下运行结果：

fun_1()输出：g_1_1
fun_2()输出：1
fun_1()输出：g_2_1
fun_2()输出：2
fun_1()输出：g_3_1
fun_2()输出：3

 说明一下：

　　上面三种方法都可以拿到范型类的对象，并且都可以正常运行。

那么来看看，这三个对象在调用范型类的范型方法的时候，编译器是如何处理的!!!

(1)使用范型，编译器是如何处理的？

//使用范型：三种方法均可
        GenericClass<String, Integer> g_1=new GenericClass<String, Integer>("type_String");
        GenericClass<String, Integer> g_2=new GenericClass("type_String");
        GenericClass<String, Integer> g_3=new GenericClass<>("type_String");//jre1.7及以上:菱形运算符
        //开始调用方法
        g_1.fun_1("g_1_1");//jre1.5及以上
        g_1.fun_2(1);
        
        g_2.fun_1("g_2_1");//jre1.5及以上
        g_2.fun_2(2);
        
        g_3.fun_1("g_3_1");//jre1.7及以上
        g_3.fun_2(3);

 

如下图：

　　

从上图可以很明显的看到，在编译的时候，编译器就已经为范型确定了指定的类型，这个时候如果我们想要使用这些方法，就必须按照指定的类型进行传参，否则编译报错。

以此类推，g_2,g_3对象都是这样的情况。

（2）继续看一下：如果不使用范型，编译是如何让处理的呢？

//不使用范型
        GenericClass g_4=new GenericClass("type_String");

  如下图所示：

可以看到，在实例化范型类的时候，并没有指定类型，然后直接调用范型类中的范型方法，编译器没有找到指定的类型，就默认为Object基类来处理了！

这样的话，就会出现，传入各种引用类型均不会编译报错，但是在方法体中处理这些数据的时候，有可能出现数据类型转换失败的异常：ClassCastException。

而如果使用了范型，就可以在编译的时候抛出异常，更方便我们编码，效果会好很多。

 三、范型的扩展

先补充一个知识点：

　　Java中数组具有“协变性”，但是集合Collection不具有协变性。

　　“协变性”：可以理解为兼容性。

　数组的协变性的简单案例如下：　　

1 package com.xfwl.generics;
2 /**
3  * 数据结构与算法分析：第一章
4  * @function  数组类型的兼容性
5  * @author 小风微凉
6  * @time  2018-5-6 下午1:26:52
7  */
8 public class ArrayParent {}

 

 1 package com.xfwl.generics;
 2 public class Test {
 3     /**
 4      * @param args
 5      */
 6     public static void main(String[] args) {
 7         //验证数组具有兼容性
 8         //创建三个数组
 9         ArrayParent[] par={};
10         ArraySon_1[] son1={};
11         ArraySon_2[] son2={};
12         
13         //开始测试
14         fun_3(par);
15         fun_3(son1);
16         fun_3(son2);
17     }
18     private static void fun_3(ArrayParent[] arr){}    
19     private class  ArraySon_1 extends ArrayParent{}
20     private class  ArraySon_2 extends ArrayParent{}
21 }

  （1）带有限制的通配符

   　　由上面可以看出数组具有协变性，导致代码得以编译，不会在编译的时候报红，因为真正地在进行类型转换是在JVM运行的时候，如果此时有问题，会产生一个运行时异常（一个ArrayStoreException)。而使用范型的全部原因就在于产生编译器错误，而不是类型不匹配的运行时异常。所以范型集合是不协变的。

　　所以可以存在：传入数组参数（支持协变性）　　

private static void fun_3(ArrayParent[] arr){}

 　　却不能写成：　

private static void fun_3(Collection<ArrayParent> arr){}  
说明：如果按照上面这行代码的效果，我们调用fun_3(...)的时候就只能传参：Collection<ArrayParent>这种类型的参数，而不支持Collection<ArraySon_1>这种类型的参数

 　　现在的问题是，范型（以及范型集合）不是协变性的（但有意义），而数组是协变性的。若无附加的语法，则用户就会避免使用集合Collection,因为失去协变性使得代码缺少灵活性。

      Java5中的“通配符”来弥补这个不足，通配符用来表示参数类型的子类（或者超类）。

　现在贴出一个例子：　　

 1 package com.xfwl.generics;
 2 
 3 import java.util.ArrayList;
 4 import java.util.Collection;
 5 import java.util.Iterator;
 6 
 7 /**
 8  * 数据结构与算法分析：第一章
 9  * @function  范型通配符
10  * @author 小风微凉
11  * @time  2018-5-6 下午2:46:56
12  */
13 public class Test2<T> {
14 
15     public static void main(String[] args) {
16         System.out.println("***【1】***********************");
17         //开始测试：范型的通配符
18         Collection<ArrayParent> list=new ArrayList<>();
19         list.add(new ArrayParent());
20         list.add(new ArraySon_1());
21         list.add(new ArraySon_2());        
22         fun_4(list);        
23         Collection<ArraySon_1> list2=new ArrayList<>();
24         list2.add(new ArraySon_1());
25         fun_4(list2);//编译通过，运行正常
26         
27         System.out.println("***【2】***********************");
28         //测试?extends T
29         Collection<ArraySon_1> list3=new ArrayList<>();
30         list3.add(new ArraySon_1());
31         fun_5(list3);//编译通过，运行正常
32         
33         System.out.println("***【3】***********************");
34         Collection<ArrayParent> list4=new ArrayList<>();
35         list4.add(new ArrayParent());
36         fun_6(list4);//编译通过
37         //fun_6(list3);//编译不通过，报错The method fun_6(Collection<? super Test2.ArraySon_2>) in the type Test2<T> is not applicable for the arguments (Collection<Test2.ArraySon_1>)
38     }
39     private static void fun_3(ArrayParent[] arr){}
40     @SuppressWarnings("unused")
41     private static void fun_4(Collection<?> arr){//？表示随便什么类型
42         Iterator<?> it= arr.iterator();
43         for(;it.hasNext();){
44             System.out.println(it.next().toString());
45         }
46     }
47     @SuppressWarnings("unused")
48     private static void fun_5(Collection<? extends ArrayParent> arr){//？表示ArrayParent的子类
49         Iterator<?> it= arr.iterator();
50         for(;it.hasNext();){
51             System.out.println(it.next().toString());
52         }
53     }
54     @SuppressWarnings("unused")
55     private static void fun_6(Collection<? super ArraySon_2> arr){//？表示ArraySon_2的超类
56         Iterator<?> it= arr.iterator();
57         for(;it.hasNext();){
58             System.out.println(it.next().toString());
59         }
60     }
61     private static class  ArraySon_1 extends ArrayParent{
62         @Override
63         public String toString() {            
64             return "ArraySon_1_toString()";
65         }
66     }
67     private static class  ArraySon_2 extends ArrayParent{
68         @Override
69         public String toString() {
70             return "ArraySon_2_toString()";
71         }
72     }
73 }

  看一下运行结果：

***【1】***********************
com.xfwl.generics.ArrayParent@626b2d4a
ArraySon_1_toString()
ArraySon_2_toString()
ArraySon_1_toString()
***【2】***********************
ArraySon_1_toString()
***【3】***********************
com.xfwl.generics.ArrayParent@5e91993f

 值得说明的是:

　（1）通配符指的是“?”，不信？那么如果把参数：Collection<?> arr    改为：Collection<T> arr,会出现什么情况呢？

　　　　经过我的测试如下图：

　　

Cannot make a static reference to the non-static type T

翻译之后：“ 不能对非静态类型T进行静态引用”

那么修改一下代码：但是这就牵扯到了范型的另外一个用法：范型的static方法，如下

（2）范型的static方法

　　上面的代码中，我们知道，范型不能应用与一般的static方法结构的方法定义中。如果一定要使用范型的static方法，则必须按照固定的格式去定义才可以通过编译。

　　static方法固定格式：

　　　　访问权限修饰符  static  <范型T,...>  返回类型  方法名称（范型T t）{}

　　根据上面的格式：简单罗列几种可能出现的方法定义的样式：如下　　

/**
     * 范型static方法
     *     格式：一定要在static后面跟上<范型>才不会编译报错
     */
    public static <T> void fun_7(T t) {
        System.out.println("fun_7()输出："+t);
    }
    
    public static <T> T fun_8(T t) {
        System.out.println("fun_8()输出："+t);
        return t;
    }

 　　所以：此时就可以改造一下上面范型类：GenericClass<T,E>中的单例模式的代码了！ 

private static GenericClass generic=null;
    private GenericClass(T t){
        this.att1=t;
    }
    //单例模式-懒汉式:范型不能用于static修饰的属性或方法中
    public static <T,E> GenericClass getSingleInstence(T t){
        if(generic==null){
            generic=new GenericClass<T,E>(t);
        }
        return generic;
    }

 分析一下：

　　从上面代码可以看到：静态方法getSingleInstence(T t)的修饰符<T,E>有范型T和范型E两种范型，而方法体中，也使用到了范型T和范型E。

或许你会有点好奇，既然泛型类：GenericClass<T,E>中已经申明了范型E,那么方法getSingleInstence(T t)的范型修饰符中能不能不用到E,或者T呢？

带着这个疑问，继续测试一下：

　　

       

 从上面两个截图中就可以看出来：范型static方法，必须在static后面紧接着跟上 这个方法体和参数定义中的范型类型，缺一不可。

但是顺序是可以不固定的：如下：

public static <E,T> GenericClass getSingleInstence(T t){}
或者
public static <T,E> GenericClass getSingleInstence(T t){}

 (3) 范型类型的限定

　　类型限界在尖括号内指定，它指参数类型必须具有的性质。

　　这里有一个看起来非常浮复杂的方法定义语句，但是关于范型最复杂的方法定义语句，估计也就是这个样子的了。

 1 /**
 2      * 求数组中的最大值
 3      * @param arr 范型数组
 4      * @return    返回的最大值
 5      */
 6     public static <T extends Comparable<? super T>,E> T findMax(T[] arr){
 7         int maxIndex=0;
 8         for(int i=0;i<arr.length;i++){
 9             if(arr[i].compareTo(arr[maxIndex])>0){
10                 maxIndex=i;
11             }
12         }        
13         return arr[maxIndex];        
14     }

 简单分析一下上面这个方法吧！

     其实，如果经过上面的各个案例的分析说明，这个方法的定义格式就很好理解了。

（1）理解：Comparable<? super T>

　　含义：理解之前需要了解Compareable这个接口是怎样的：

public interface Comparable<T> {

 然后Comparable<? super T>，表示Compareable这个接口的比较类型?(通配符）是一个范型类T的父类。

（2）理解：T extends Comparable<? super T>

        含义：表示实现了一个类型T,该类型T是Compareable接口实现类的子类,该Compareable接口实现类的比较类型是T的父类（超类或基类）。

　　　　　（好像是有点绕啊，有更好的理解，欢迎指点。）

（3）理解：<T extends Comparable<? super T>,E>

       含义：声明两种范型类型

（4）理解：T[] arr

　　含义：传入的参数，范型T的数组

（5）理解:findMax方法体

　　含义：比较找出当前数组中的最大的数据。运用了CompareTo方法，需要说明的是，当前的范型T的对象，都是实现了接口Compareable的类的对象。

（4）范型的类型擦除

　　 范型在很大程度上是Java语言中的成分而不是虚拟机中的结构，范型可以由编译器通过所谓的“类型擦除”（type erasure）过程而转变成非泛型类。这样，编译器就生产一种与范型类同名的原始类，

但是类型参数都被删除了。类型变量由他们的类型限界来代替，当一个具有擦除返回类型的范型方法被调用的时候，一些特性被自动地插入。如果使用一个范型类而不带类型参数，那么使用的是原始类。

　　类型擦除的一个重要的推论是，所生产的代码与程序员在范型之前所写的代码并没有太多的差异，而且事实上运行的也并不快。其显著地优点在于，程序员不比把一些类型转换放到代码中，编译器经进行重要的类型检查。

（5）对于范型的限制

　　对于范型有许多的限制，由于类型擦除的原因，这里列出的每一个限制都必须遵守。

  • 基本类型

　　　　基本类型不能用作类型参数，因此，GenericClass<T,E>正确，但是GenericClass<int>　是非法的。必须使用包装类！

  • instanceof检测

　　　　instanceof检测和类型转换只对原始类型进行

  • static的语境　　

　　　　在一个范型类中，static方法和static域均不可引用类的类型变量，因为在类型擦除后类型变量就不存在了，另外，由于实际上只存在一个原始的类，因此static域在诸多范型实例之间是共享的。

  • 范型类型的实例化

　　     不能创建一个范型类型的实例，如果T是一个变量，则语句：  T t=new T()；//是非法的。　T由他的界限替代，可能是Object或者是抽象类，所以对new的调用没有意义。

  • 范型的数组对象　　

　　    不能创建一个范型数组，如果T是一个类型变量，则语句 T[]  arr=new T[10];//是不合法的。T将由他的界限代替，可很能是Object T，于是（由于类型擦除产生的）对T[]的类型转换将无法进行，因为Object[]   不是T[]。

  • 参数化类型的数组　　

　　　　参数化类型的数组的实例化是非法的。比如下面这样的：

　　GenericClass<String, Integer>[]   g_1  =new GenericClass<> [10];//这是非法的，会报编译异常

好了，范型的学习也差不多了，到此告一段落了。以后有新的发现会继续研究。 

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：ElasticSearch学习

下一篇：多线程之死锁就是这么简单

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签