Java泛型.docx
- 文档编号:4672134
- 上传时间:2022-12-07
- 格式:DOCX
- 页数:45
- 大小:39.24KB
Java泛型.docx
《Java泛型.docx》由会员分享,可在线阅读,更多相关《Java泛型.docx(45页珍藏版)》请在冰豆网上搜索。
Java泛型
Java泛型
资料一:
泛型是JAVASE1.5的新特性,泛型的本质是参数化类型,也就是说所操作的数据类型被指定为一个参数。
这种参数类型可以用在类、接口和方法的创建中,分别称为泛型类、泛型接口、泛型方法。
JAVA语言引入泛型的好处是安全简单。
在JAVASE1.5之前,没有泛型的情况的下,通过对类型Object的引用来实现参数的“任意化”,“任意化”带来的缺点是要做显式的强制类型转换,而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。
对于强制类型转换错误的情况,编译器可能不提示错误,在运行的时候才出现异常,这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全,并且所有的强制转换都是自动和隐式的,提高代码的重用率。
泛型在使用中还有一些规则和限制:
1、泛型的类型参数只能是类类型(包括自定义类),不能是简单类型。
2、同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句,例如
习惯上成为“有界类型”。
5、泛型的参数类型还可以是通配符类型。
例如Class
>classType=Class.forName(java.lang.String);
例一:
使用了泛型:
查看复制到剪切板打印
1.public class Gen
2. private T ob; //定义泛型成员变量
3.
4. public Gen(T ob) {
5. this.ob = ob;
6. }
7.
8. public T getOb() {
9. return ob;
10. }
11.
12. public void setOb(T ob) {
13. this.ob = ob;
14. }
15.
16. public void showTyep() {
17. System.out.println("T的实际类型是:
" + ob.getClass().getName());
18. }
19.}
20.
21.public class GenDemo {
22. public static void main(String[] args){
23. //定义泛型类Gen的一个Integer版本
24. Gen
25. intOb.showTyep();
26. int i= intOb.getOb();
27. System.out.println("value= " + i);
28.
29. System.out.println("----------------------------------");
30.
31. //定义泛型类Gen的一个String版本
32. Gen
");
33. strOb.showTyep();
34. String s=strOb.getOb();
35. System.out.println("value= " + s);
36. }
37.}
publicclassGen
privateTob;//定义泛型成员变量
publicGen(Tob){
this.ob=ob;
}
publicTgetOb(){
returnob;
}
publicvoidsetOb(Tob){
this.ob=ob;
}
publicvoidshowTyep(){
System.out.println("T的实际类型是:
"+ob.getClass().getName());
}
}
publicclassGenDemo{
publicstaticvoidmain(String[]args){
//定义泛型类Gen的一个Integer版本
Gen
intOb.showTyep();
inti=intOb.getOb();
System.out.println("value="+i);
System.out.println("----------------------------------");
//定义泛型类Gen的一个String版本
Gen
");
strOb.showTyep();
Strings=strOb.getOb();
System.out.println("value="+s);
}
}
例二:
没有使用泛型时:
查看复制到剪切板打印
1.public class Gen2 {
2. private Object ob; //定义一个通用类型成员
3.
4. public Gen2(Object ob) {
5. this.ob = ob;
6. }
7.
8. public Object getOb() {
9. return ob;
10. }
11.
12. public void setOb(Object ob) {
13. this.ob = ob;
14. }
15.
16. public void showTyep() {
17. System.out.println("T的实际类型是:
" + ob.getClass().getName());
18. }
19.}
20.
21.
22.public class GenDemo2 {
23. public static void main(String[] args) {
24. //定义类Gen2的一个Integer版本
25. Gen2 intOb = new Gen2(new Integer(88));
26. intOb.showTyep();
27. int i = (Integer) intOb.getOb();
28. System.out.println("value= " + i);
29.
30. System.out.println("----------------------------------");
31.
32. //定义类Gen2的一个String版本
33. Gen2 strOb = new Gen2("Hello Gen!
");
34. strOb.showTyep();
35. String s = (String) strOb.getOb();
36. System.out.println("value= " + s);
37. }
38.}
publicclassGen2{
privateObjectob;//定义一个通用类型成员
publicGen2(Objectob){
this.ob=ob;
}
publicObjectgetOb(){
returnob;
}
publicvoidsetOb(Objectob){
this.ob=ob;
}
publicvoidshowTyep(){
System.out.println("T的实际类型是:
"+ob.getClass().getName());
}
}
publicclassGenDemo2{
publicstaticvoidmain(String[]args){
//定义类Gen2的一个Integer版本
Gen2intOb=newGen2(newInteger(88));
intOb.showTyep();
inti=(Integer)intOb.getOb();
System.out.println("value="+i);
System.out.println("----------------------------------");
//定义类Gen2的一个String版本
Gen2strOb=newGen2("HelloGen!
");
strOb.showTyep();
Strings=(String)strOb.getOb();
System.out.println("value="+s);
}
}
运行结果:
两个例子运行Demo结果是相同的,控制台输出结果如下:
T的实际类型是:
java.lang.Integer
value=88
----------------------------------
T的实际类型是:
java.lang.String
value=HelloGen!
Processfinishedwithexitcode0
补充:
实际上泛型可以用得很复杂,复杂到编写代码的人员自己也难以看懂。
这往往是对泛型的滥用或者类或接口本身设计不合理导致的。
看来用好泛型还真不容易,为此必须从根源说起。
一、逐渐深入泛型
1、没有任何重构的原始代码:
有两个类如下,要构造两个类的对象,并打印出各自的成员x。
查看复制到剪切板打印
1.public class StringFoo {
2. private String x;
3.
4. public StringFoo(String x) {
5. this.x = x;
6. }
7.
8. public String getX() {
9. return x;
10. }
11.
12. public void setX(String x) {
13. this.x = x;
14. }
15.}
16.
17.public class DoubleFoo {
18. private Double x;
19.
20. public DoubleFoo(Double x) {
21. this.x = x;
22. }
23.
24. public Double getX() {
25. return x;
26. }
27.
28. public void setX(Double x) {
29. this.x = x;
30. }
31.}
publicclassStringFoo{
privateStringx;
publicStringFoo(Stringx){
this.x=x;
}
publicStringgetX(){
returnx;
}
publicvoidsetX(Stringx){
this.x=x;
}
}
publicclassDoubleFoo{
privateDoublex;
publicDoubleFoo(Doublex){
this.x=x;
}
publicDoublegetX(){
returnx;
}
publicvoidsetX(Doublex){
this.x=x;
}
}
2、对上面的两个类进行重构,写成一个类:
因为上面的类中,成员和方法的逻辑都一样,就是类型不一样,因此考虑重构。
Object是所有类的父类,因此可以考虑用Object做为成员类型,这样就可以实现通用了,实际上就是“Object泛型”,暂时这么称呼。
查看复制到剪切板打印
1.public class ObjectFoo {
2. private Object x;
3.
4. public ObjectFoo(Object x) {
5. this.x = x;
6. }
7.
8. public Object getX() {
9. return x;
10. }
11.
12. public void setX(Object x) {
13. this.x = x;
14. }
15.}
publicclassObjectFoo{
privateObjectx;
publicObjectFoo(Objectx){
this.x=x;
}
publicObjectgetX(){
returnx;
}
publicvoidsetX(Objectx){
this.x=x;
}
}
写出Demo方法如下:
查看复制到剪切板打印
1.public class ObjectFooDemo {
2. public static void main(String args[]) {
3. ObjectFoo strFoo = new ObjectFoo("Hello Generics!
");
4. ObjectFoo douFoo = new ObjectFoo(new Double("33"));
5. ObjectFoo objFoo = new ObjectFoo(new Object());
6.
7. System.out.println("strFoo.getX="+(String)strFoo.getX());
8. System.out.println("douFoo.getX="+(Double)douFoo.getX());
9. System.out.println("objFoo.getX="+(Object)objFoo.getX());
10. }
11.}
publicclassObjectFooDemo{
publicstaticvoidmain(Stringargs[]){
ObjectFoostrFoo=newObjectFoo("HelloGenerics!
");
ObjectFoodouFoo=newObjectFoo(newDouble("33"));
ObjectFooobjFoo=newObjectFoo(newObject());
System.out.println("strFoo.getX="+(String)strFoo.getX());
System.out.println("douFoo.getX="+(Double)douFoo.getX());
System.out.println("objFoo.getX="+(Object)objFoo.getX());
}
}
运行结果如下:
strFoo.getX=HelloGenerics!
douFoo.getX=33.0
objFoo.getX=java.lang.Object@19821f
解说:
在Java5之前,为了让类有通用性,往往将参数类型、返回类型设置为Object类型,当获取这些返回类型来使用时候,必须将其“强制”转换为原有的类型或者接口,然后才可以调用对象上的方法。
3、Java5泛型来实现
强制类型转换很麻烦,我还要事先知道各个Object具体类型是什么,才能做出正确转换。
否则,要是转换的类型不对,比如将“HelloGenerics!
”字符串强制转换为Double,那么编译的时候不会报错,可是运行的时候就挂了。
那有没有不强制转换的办法----有,改用Java5泛型来实现。
查看复制到剪切板打印
1.public class GenericsFoo
2. private T x;
3.
4. public GenericsFoo(T x) {
5. this.x = x;
6. }
7.
8. public T getX() {
9. return x;
10. }
11.
12. public void setX(T x) {
13. this.x = x;
14. }
15.}
16.
17.public class GenericsFooDemo {
18. public static void main(String args[]){
19. GenericsFoo
");
20. GenericsFoo
21. GenericsFoo
22.
23. System.out.println("strFoo.getX="+strFoo.getX());
24. System.out.println("douFoo.getX="+douFoo.getX());
25. System.out.println("objFoo.getX="+objFoo.getX());
26. }
27.}
publicclassGenericsFoo
privateTx;
publicGenericsFoo(Tx){
this.x=x;
}
publicTgetX(){
returnx;
}
publicvoidsetX(Tx){
this.x=x;
}
}
publicclassGenericsFooDemo{
publicstaticvoidmain(Stringargs[]){
GenericsFoo
");
GenericsFoo
GenericsFoo
System.out.println("strFoo.getX="+strFoo.getX());
System.out.println("douFoo.getX="+douFoo.getX());
System.out.println("objFoo.getX="+objFoo.getX());
}
}
运行结果:
strFoo.getX=HelloGenerics!
douFoo.getX=33.0
objFoo.getX=java.lang.Object@19821f
和使用“Object泛型”方式实现结果的完全一样,但是这个Demo简单多了,里面没有强制类型转换信息。
下面解释一下上面泛型类的语法:
使用
当然T仅仅是个名字,这个名字可以自行定义。
classGenericsFoo
与Object泛型类相比,使用泛型所定义的类在声明和构造实例的时候,可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。
类如
GenericsFoo
当然,也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型,但是你在使用该对象的时候,就需要强制转换了。
比如:
Generi
- 配套讲稿:
如PPT文件的首页显示word图标,表示该PPT已包含配套word讲稿。双击word图标可打开word文档。
- 特殊限制:
部分文档作品中含有的国旗、国徽等图片,仅作为作品整体效果示例展示,禁止商用。设计者仅对作品中独创性部分享有著作权。
- 关 键 词:
- Java 泛型