Java 泛型 一
泛型在Java中有很重要的地位,网上很多文章罗列各种理论,不便于理解,本篇将立足于代码介绍、总结了关于泛型的知识。
先看下面的代码:
- List list = new ArrayList();
- list.add("CSDN_SEU_Calvin");
- list.add(100);
- for (int i = 0; i < list.size(); i++) {
- String name = (String) list.get(i); //取出Integer时,运行时出现异常
- System.out.println("name:" + name);
- }
本例向list类型集合中加入了一个字符串类型的值和一个Integer类型的值(这样是合法的,因为此时list默认的类型为Object类型)。
在循环中,由于忘记了之前添加了Integer类型的值或其他原因,运行时会出现java.lang.ClassCastException。为了解决这个问题,泛型应运而生。
2.泛型的使用
Java泛型编程是JDK1.5版本后引入的。泛型让编程人员能够使用类型抽象,通常用于集合里面。
只要在上例中将第1行代码改成如下形式,那么就会在编译list.add(100)时报错。
- List<String> list = new ArrayList<String>();
通过List<String>,直接限定了list集合中只能含有String类型的元素,从而在上例中的第6行中,无须进行强制类型转换,因为集合能够记住其中元素的类型信息,编译器已经能够确认它是String类型了。
3.泛型只在编译阶段有效
看下面的代码:
- ArrayList<String> a = new ArrayList<String>();
- ArrayList b = new ArrayList();
- Class c1 = a.getClass();
- Class c2 = b.getClass();
- System.out.println(c1 == c2); //true
上面程序的输出结果为true。因为所有反射的操作都是在运行时的,既然为true,就证明了编译之后,程序会采取去泛型化的措施。
也就是说Java中的泛型,只在编译阶段有效。在编译过程中,正确检验泛型结果后,会将泛型的相关信息擦出,并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说,成功编译过后的class文件中是不包含任何泛型信息的。
上述结论可通过下面反射的例子来印证:
- ArrayList<String> a = new ArrayList<String>();
- a.add("CSDN_SEU_Calvin");
- Class c = a.getClass();
- try{
- Method method = c.getMethod("add",Object.class);
- method.invoke(a,100);
- }catch(Exception e){
- e.printStackTrace();
- }System.out.println(a);
因为绕过了编译阶段也就绕过了泛型,输出结果为:
- [CSDN_SEU_Calvin, 100]
4.泛型类和泛型方法
如下,我们看一个泛型类和方法的使用例子,和未使用泛型的使用方法进行了对比,两者输出结果相同,在这里贴出来方便读者体会两者的差异。泛型接口的例子有兴趣可以去找一些资料,这里就不赘述了。
(1)使用泛型的情况
- public static class FX<T> {
- private T ob; // 定义泛型成员变量
- public FX(T ob) {
- this.ob = ob;
- }
- public T getOb() {
- return ob;
- }
- public void showType() {
- System.out.println("T的实际类型是: " + ob.getClass().getName());
- }
- }
- public static void main(String[] args) {
- FX<Integer> intOb = new FX<Integer>(100);
- intOb.showType();
- System.out.println("value= " + intOb.getOb());
- System.out.println("----------------------------------");
- FX<String> strOb = new FX<String>("CSDN_SEU_Calvin");
- strOb.showType();
- System.out.println("value= " + strOb.getOb());
- }
(2)不使用泛型的情况
- public static class FX {
- private Object ob; // 定义泛型成员变量
- public FX(Object ob) {
- this.ob = ob;
- }
- public Object getOb() {
- return ob;
- }
- public void showType() {
- System.out.println("T的实际类型是: " + ob.getClass().getName());
- }
- }
- public static void main(String[] args) {
- FX intOb = new FX(new Integer(100));
- intOb.showType();
- System.out.println("value= " + intOb.getOb());
- System.out.println("----------------------------------");
- FX strOb = new FX("CSDN_SEU_Calvin");
- strOb.showType();
- System.out.println("value= " + strOb.getOb());
- }
两种写法输出结果均为:
- T的实际类型是: java.lang.Integer
- value= 100
- ----------------------------------
- T的实际类型是: java.lang.String
- value= CSDN_SEU_Calvin
5.通配符
为了引出通配符的概念,先看如下代码:
- List<Integer> ex_int= new ArrayList<Integer>();
- 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<?>即可。
下面这个例子也说明了这一点,注释已经写的很清楚了。
- public static void main(String[] args) {
- FX<Number> ex_num = new FX<Number>(100);
- FX<Integer> ex_int = new FX<Integer>(200);
- getData(ex_num);
- getData(ex_int);//编译错误
- }
- public static void getData(FX<Number> temp) { //此行若把Number换为“?”编译通过
- //do something...
- }
- public static class FX<T> {
- private T ob;
- public FX(T ob) {
- this.ob = ob;
- }
- }
6.上下边界
看了下面这个上边界的例子就明白了,下界FX<? supers Number>的形式就不做过多赘述了。
- public static void main(String[] args) {
- FX<Number> ex_num = new FX<Number>(100);
- FX<Integer> ex_int = new FX<Integer>(200);
- getUpperNumberData(ex_num);
- getUpperNumberData(ex_int);
- }
- public static void getUpperNumberData(FX<? extends Number> temp){
- System.out.println("class type :" + temp.getClass());
- }
- public static class FX<T> {
- private T ob;
- public FX(T ob) {
- this.ob = ob;
- }
- }
7.泛型的好处
(1)类型安全。
通过知道泛型定义的变量类型限制,编译器可以更有效地提高Java程序的类型安全。
(2)消除强制类型转换。
消除源代码中的许多强制类型转换。这使得代码更加可读,并且减少了出错机会。所有的强制转换都是自动和隐式的。
(3)提高性能。
- Lits list1 = new ArrayList();
- list1.add("CSDN_SEU_Calvin ");
- String str1 = (String)list1.get(0);
- List<String> list2 = new ArrayList<String>();
- list2.add("CSDN_SEU_Calvin ");
- String str2 = list2.get(0);
对于上面的两段程序,由于泛型所有工作都在编译器中完成,javac编译出来的字节码是一样的(只是更能确保类型安全),那么何谈性能提升呢?是因为在泛型的实现中,编译器将强制类型转换插入生成的字节码中,但是更多类型信息可用于编译器这一事实,为未来版本的 JVM 的优化带来了可能。
8.泛型使用的注意事项
(1)泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
(2)泛型的类型参数可以有多个。
(3)不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的,编译时会出错。
- if(ex_num instanceof FX<Number>){
- }
(4)不能创建一个确切的泛型类型的数组。下面使用Sun的一篇文档的一个例子来说明这个问题:
- List<String>[] lsa = new List<String>[10]; // Not really allowed.
- Object o = lsa;
- Object[] oa = (Object[]) o;
- List<Integer> li = new ArrayList<Integer>();
- li.add(new Integer(3));
- oa[1] = li; // Unsound, but passes run time store check
- String s = lsa[1].get(0); // Run-time error: ClassCastException.
这种情况下,由于JVM泛型的擦除机制,在运行时JVM是不知道泛型信息的,所以可以给oa[1]赋上一个ArrayList<Integer>而不会出现异常,但是在取出数据的时候却要做一次类型转换,所以就会出现ClassCastException,如果可以进行泛型数组的声明,上面说的这种情况在编译期将不会出现任何的警告和错误,只有在运行时才会出错。
下面采用通配符的方式是被允许的:
- List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.
- Object o = lsa;
- Object[] oa = (Object[]) o;
- List<Integer> li = new ArrayList<Integer>();
- li.add(new Integer(3));
- oa[1] = li; // Correct.
- Integer i = (Integer) lsa[1].get(0); // OK
9.List与List<?>
(1)List实际上也是List<Object>。List实际上表示持有任何Object类型的原生List。
(2)而List<?>表示具有某种特定类型的非原生List,只是我们不知道那种类型是什么。
转载:http://blog.csdn.net/seu_calvin/article/details/52230032
Java 泛型 一的更多相关文章
- Java泛型的历史
为什么Java泛型会有当前的缺陷? 之前的章节里已经说明了Java泛型擦除会导致的问题,C++和C#的泛型都是在运行时存在的,难道Java天然不支持“真正的泛型”吗? 事实上,在Java1.5在200 ...
- 浅析Java 泛型
泛型是JavaSE5引入的一个新概念,但是这个概念在编程语言中却是很普遍的一个概念.下面,根据以下内容,我们总结下在Java中使用泛型. 泛型使用的意义 什么是泛型 泛型类 泛型方法 泛型接口 泛型擦 ...
- Java:泛型基础
泛型 引入泛型 传统编写的限制: 在Java中一般的类和方法,只能使用具体的类型,要么是基本数据类型,要么是自定义类型.如果要编写可以应用于多种类型的代码,这种刻板的限制就会束缚很多! 解决这种限制的 ...
- java泛型基础
泛型是Java SE 1.5的新特性, 泛型的本质是参数化类型, 也就是说所操作的数据类型被指定为一个参数. 这种参数类型可以用在类.接口和方法的创建中, 分别称为泛型类.泛型接口.泛型方法. Ja ...
- 使用java泛型设计通用方法
泛型是Java SE 1.5的新特性, 泛型的本质是参数化类型, 也就是说所操作的数据类型被指定为一个参数. 因此我们可以利用泛型和反射来设计一些通用方法. 现在有2张表, 一张user表和一张stu ...
- 关于Java泛型的使用
在目前我遇到的java项目中,泛型应用的最多的就属集合了.当要从数据库取出多个对象或者说是多条记录时,往往都要使用集合,那么为什么这么使用,或者使用时有什么要注意的地方,请关注以下内容. 感谢Wind ...
- 初识java泛型
1 协变数组类型(covariant array type) 数组的协变性: if A IS-A B then A[] IS-A B[] 也就是说,java中的数组兼容,一个类型的数组兼容他的子类类型 ...
- 【Java心得总结四】Java泛型下——万恶的擦除
一.万恶的擦除 我在自己总结的[Java心得总结三]Java泛型上——初识泛型这篇博文中提到了Java中对泛型擦除的问题,考虑下面代码: import java.util.*; public clas ...
- 【Java心得总结三】Java泛型上——初识泛型
一.函数参数与泛型比较 泛型(generics),从字面的意思理解就是泛化的类型,即参数化类型.泛型的作用是什么,这里与函数参数做一个比较: 无参数的函数: public int[] newIntAr ...
- 初识Java泛型以及桥接方法
泛型的由来 在编写程序时,可能会有这样的需求:容器类,比如java中常见的list等.为了使容器可以保存多种类型的数据,需要编写多种容器类,每一个容器类中规定好了可以操作的数据类型.此时可能会有Int ...
随机推荐
- 新进Linux菜鸟,请多多关照
早早知晓Linux的大名,一直未研究学习,近来看了kernel一些源代码,在网上搜过很多基础的知识.感觉这个Linux的世界很广大,值得好好深入学习.初生婴儿,呱呱落地,必先躺若干日后能坐,在学爬,进 ...
- 04001_HTML简单介绍
1.超文本标记语言 (1)超文本:比普通文本功能更加强大: (2)标记语言:使用一组标签对内容进行描述的一门语言,它不是编程语言! 2.HTML语法和规范 (1)所有的html文件后缀名都是以.htm ...
- js获取指定字符前/后的字符串简单实例
<!doctype html> <html> <head> <meta charset="utf-8"> <title> ...
- Linux下启用IP转发功能(主要针对Ubuntu的使用)
说明:以下的操作只要在Linux下都是通用的. Linux发行版默认情况下是不开启IP转发功能的.如果架设一个Linux路由或者VPN服务就需要开启该服务. 1.通过访问sysctl的内核ipv4.i ...
- ETL全量单表同步简述
ETL全量单表同步简述 1. 实现需求 当原数据库的表有新增.更新.删除操作时,将改动数据同步到目标库对应的数据表. 2. 设计思路 设计总体流程图如下: 注意点: 1.数据库合并时,选择正确的数据源 ...
- 【nginx】【转】正向代理与反向代理的区别[
转自: http://blog.csdn.net/m13666368773/article/details/8060481 正向代理的概念 正向代理,也就是传说中的代理,他的工作原理就像一个跳板,简单 ...
- Android之AssetManager使用
1. 获取AssetManager AssetManager assetManager = context.getAssets(); 2. 列出assets文件夹下全部文件 String[] file ...
- 018 cisco 3560 MAC地址绑定
在3560交换机上show ip dhcp binding 可以看到通过DHCP服务广播出去的IP地址与MAC地址的对应表: 比如: Switch#show ip dhcp binding IP ad ...
- MAVEN项目模块化
maven的最大的特点之中的一个就是能够把项目模块化. 前面的一篇文章MAVEN创建并打包web项目已经创建了一个简单的webapp,注意这个webapp的打包方式是war. 假设如今又要划分出来一个 ...
- 如何在其他js 引入main.js 中 vue 的实例?
1.原因解析 经测试发现,代码先执行了 index.js >> main.js >> Home.vue scr/api/index.js src/main.js src/co ...