java 泛型属性_Java泛型(Generics)详解

1、导读

泛型是Java SE 1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。Generic有“类的,属性的”之意,在Java中代表泛型。泛型作为一种安全机制而产生。

2、为何需要泛型?

我们知道集合(Collection、Map之类的容器)是用来存储任意对象(Object)的一系列“容器类或者接口”,注意这里的“任意对象”,就是指我们可以在这些类或接口中存放任意类型的对象,但这些对象在存储之前都需要统一向上转型为Object类型(因为Object类是所以类的的父类),比如类ArrayList就属于“集合类”,我们可以用这个类来存储任意对象:

packagebean;importjava.util.ArrayList;public classArrayListDemo {public static voidmain(String[] args) {//首先我们创建一个ArrayList对象

ArrayList al = newArrayList();//往"容器"添加元素:我们添加了字符串"哈哈",数字2,boolean类型true,最后我们甚至添加了自己。

al.add("哈哈");

al.add(2);

al.add(true);

al.addAll(al);//由于ArrayList类覆盖了toString(),这里我们可以直接打印查看效果:

System.out.println(al);

}

}

最后打印出来的字符串是:[哈哈, 2, true, 哈哈, 2, true]

值得注意的是:这里的2不是int而是Integer,因为ArrayList只能存对象,而“添加它自己”addAll(al)的实质是将al中的所有元素再存入al中,正如打印效果显示的一样,我们成功添加了类型不一样的对象:有String,有Integer、还有Boolean。当然,你可以添加任意你想要添加的对象。因为这些对象在存入“容器”al中时会全部转型为Object类型,有没有觉得这样的“容器”用起来会很爽,什么东西都能往里放。但是,便捷往往会付出相应代价。

我们将各种类型的元素存入“容器”中当然不是让它睡上一觉,我们需要将存储的元素取出使用。对于这些“容器”,我们一般使用迭代器Iterator来获取每一个元素。(这里不进行迭代器使用说明,只需理解迭代器是取出"容器"中元素的工具就行).

假设现在我们需要对我们上面创建的“容器”al中的元素进行操作:打印容器中字符串的长度,即“哈哈”的长度。

1 packagebean;2

3 importjava.util.ArrayList;4 importjava.util.Iterator;5

6 public classArrayListDemo {7 public static voidmain(String[] args) {8 //首先我们创建一个ArrayList对象,并添加对象

9 ArrayList al = newArrayList();10 al.add("哈哈");11 al.add(2);12 al.add(true);13

14 //使用迭代器Iterator进行遍历,并打印容器中字符串的长度:15 //注:next()方法是按照容器的存储顺序,逐一取出第一个到最后一个对象。

16 Iterator i =al.iterator();17 while(i.hasNext()){18 String s =(String) i.next();19 System.out.println(s.length());20 }21 }22

23 }

这是运行结果:

bc49be02b093feafb6ceaea634bb525c.png

我们来进行代码分析:while循环中,先用i.next()方法取出第一个元素"哈哈",然后装换为String类型(因为存进去的时候是Object类型,使用的使用要向下转型),所以接下来打印了“哈哈”的长度=2。接着循环:迭代器取出第二个元素:2,但这是Integer类型不能强制装换为String类型,所以抛出异常:ClassCastException:类型转换异常。

这就是“能存万物”所带来的代价:我们在使用“容器”存储对象并调用时就换存在“类型转换异常”的安全隐患,但这需要在运行后才能得知,编译时无法发现。所以我们该如何解决这个问题呢?我们发现问题在于“类型转换异常”,所以我们只要保证“容器”中存储的是同一类型的元素就不会出现这个异常了。类似数组的定义一样:如 int[] 就表示专门用来存储int类型数据的数组,String[] 就是用来存储String类型数据的数组。我们只要将“容器”标上相应类型的标签就可以了。看到这里,你应该已经理解了泛型的由来,这就是泛型的设计:引入类型参数的概念,即对对象类型进行申明。

3、泛型的定义格式

格式为:类名,如:

1 packagebean;2

3 importjava.util.ArrayList;4 importjava.util.Iterator;5

6 public classArrayListDemo {7 public static voidmain(String[] args) {8 //首先我们创建一个ArrayList对象,并申明泛型类型为String类型:只能存储String类型的对象

9 ArrayList al = new ArrayList();10 al.add("哈哈");11 al.add("asdafa");12 al.add("tobeyourself");13

14 //使用迭代器Iterator进行遍历,并打印容器中字符串的长度:这里迭代器也使用了泛型

15 Iterator i =al.iterator();16 while(i.hasNext()){17 String s =(String) i.next();18 System.out.println(s+"的长度为="+s.length());19 }20 }21

22 }

运行结果为:

7bfd6b6229c58e6a117f28d3132c3fd6.png

3、泛型的好处

除了解决上面的安全隐患即抛出异常问题,泛型的类或接口在取出对象时将不需要再进行向下类型转换,因为存储的时候就是该类型 。

另外,泛型的使用让安全问题在编译时就报错而不是运行后抛出异常,这样便于程序员及时准确地发现问题。

4、什么时候使用泛型?

一般类或接口在api文档中的定义中带有标识的,在使用的时候都需要使用泛型机制。如ArrayList、Iterator。

5、泛型的擦除

泛型是运用在编译时期的技术:编译时编译器会按照的类型对容器中的元素进行检查,检查不匹配,就编译失败。如果全部检查成功,则编译通过,但,编译通过后产生的.class文件中并没有这个标识,即类文件中没有泛型,这就是泛型的擦除。

一句话总结就是:在.java文件运用泛型技术时,编译器在文件编译通过后自动擦除泛型标识。

由于泛型的擦除,类文件中没有泛型机制,同时也没有使用向下类型转换,那么为何运行时无异常?

6、泛型的补偿

编译器在擦除泛型后,会自动将类型转换为原定义的"泛型",这样就不必再做向下类型转换了。

泛型的擦除和补偿 这两个机制都是编译器内部自动完成的,了解其原理即可。

7、泛型的应用

7.1【泛型类】

所谓的泛型类就是运用到泛型技术的类,如上面讲到的ArrayList,Iterator等都是java中的泛型类,这些类都是Java已经定义好的泛型类,直接使用就可以了。但有时候我们会遇到这样的问题:

假设我们现在有两个自定义类:Worker类和Student类,现在我们需要一个工具类Tool来获取Worker对象和Student对象,并能对对象进行操作。

分析:

我们可能会想到将Worker和Student类作为Tool类的成员变量,以此来实现对这两个类的操作。但这样有一个问题,就是如果这不是两个类而是很多类,甚至说无数个类,即Tool类可以操作任意类,这种通过添加成员变量来实现调用对象的方法显然不可行。注意这个“添加任意对象”,这不就是上面说的ArrrayList这些类所具有的特点吗?泛型类就是为了解决“添加任意对象”而产生的,这里提到的ArrayList属于已定义泛型类(Java中自带的),这里我们要用到Tool类来“存储任意对象”,所以要将Tool类定义为泛型类,这就是根据需求自己设计的自定义泛型类:

首先我们先简单的定义一下:Worker类和Student类:

Worker类:

1 packagebean;2

3 public classWorker {4 privateString name;5 private intage;6 Worker(){7

8 }9 Worker(String name,intage){10 this.name =name;11 this.age =age;12 }13 publicString getName() {14 returnname;15 }16 public voidsetName(String name) {17 this.name =name;18 }19 public intgetAge() {20 returnage;21 }22 public void setAge(intage) {23 this.age =age;24 }25

26 }

Student类:

1 packagebean;2

3 public classStudent {4 privateString name;5 privateString sex;6 Student(){7

8 }9 Student(String name,String sex){10 this.name =name;11 this.sex =sex;12 }13 publicString getName() {14 returnname;15 }16 public voidsetName(String name) {17 this.name =name;18 }19 publicString getSex() {20 returnsex;21 }22 public voidsetSex(String sex) {23 this.sex =sex;24 }25

26 }

现在我们需要将Tool类定义为泛型类:(注意格式)

1 packagebean;2

3 public class Tool{4 privateE e;5

6 publicTool(E e1){7 this.e =e1;8 }9

10 publicE getE() {11 returne;12 }13 public voidsetE(E e) {14 this.e =e;15 }16

17 }

这里我们写的很简单,但已经满足需求了,重点在于泛型类的写法:Tool,这里的E字母可以写你自己喜欢的代码,这也就是类型参数的应用,E相当于一个类型参数,代表了Tool可以传入任意对象,下面我们具体使用来看看效果:

1 packagebean;2

3 classTooltest{4 public static voidmain(String[] args) {5 //假设有两个对象:一个学生,一个工人

6 Student t1 = new Student("张三","男");7 Worker w1 = new Worker("李四",20);8

9 //现在我们使用Tool类来调用t1和w1

10 Tool ts = new Tool(t1);11 Tool tw = new Tool(w1);12

13 //打印查看效果

14 System.out.println("使用ts调用t1中的数据:"+ts.getE().getName()+":"+ts.getE().getSex());15 System.out.println("使用tw调用w1中的数据:"+tw.getE().getName()+":"+tw.getE().getAge());16 }17 }

打印结果为:

使用ts调用t1中的数据:张三:男

使用tw调用w1中的数据:李四:20

7.2【泛型方法】

泛型方法类似于静态类的设计,一般的方法传入的参数是固定类型的,如public void show(int i){}这个方法的参数类型固定为int,但是泛型方法可以传入指定的参数类型。一般泛型定义有两种形式:

1)使用泛型类的参数类型来定义(常用):

如泛型类Tool,它的泛型参数即为QQ。那么泛型方法可以这样写:public void show(QQ qq){}.

2)使用自定义的参数类型来定义:

如果我们需要自定义参数类型,那么我们把泛型参数放在方法上就可以了(放在返回值类型之前):public void show(AA aa){}。

注:静态方法不能访问类的泛型,如果需要泛型,我们只能使用方法2),在方法上使用泛型即可:public static void show(AA aa){}

7.3【泛型接口】

和上面一样的道理,当我们不确定使用对象的类型时,运用泛型就可以解决问题,泛型接口和泛型类的使用是一样一样的。

我们只需要注意,在实现泛型接口时有两种情况:这里假设有泛型接口interf,它的实现类是Tool。

1)确定实现的泛型接口的参数类型:

假设Tool类需要String类型的参数,那么实现可以直接写:class Tool implements interf{}即可。

2)不确定实现的泛型接口的参数类型:

这时候我们需要泛型类来实现classTool implements interf{}.

8、泛型の通配符:?

当我们不确定传入的对象类型时我们就可以使用?来代替。“?”即泛型通配符。

9、泛型的限定

我们知道使用泛型类时:如果明确参数类型,那么泛型就代表一种类型;如果使用通配符?,那么泛型就代表任意类型。但有时候我们希望指定某些类型(不是一个,也不要所有)能作为参数类型,这应该怎么办呢?

Java中利用泛型的限定解决了这个问题,即泛型的限定。我们只需要按这样的格式书写:

上限:表示参数类型是E及其所有子类。

下限: super E>表示参数类型是E及其所有超类(即父类)。

10、总结

泛型即“类型参数化”,用的多了就懂了。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值