java基础-泛型举例详解
2018-06-18 00:31:42来源：未知 阅读 ()
泛型
泛型是JDK5.0增加的新特性，泛型的本质是参数化类型，即所操作的数据类型被指定为一个参数。这种类型参数可以在类、接口、和方法的创建中，分别被称为泛型类、泛型接口、泛型方法。
一、认识泛型
在没有泛型之前,通过对类型Object的引用来实现参数的"任意化",但"任意化"带来的缺点是需要显示的强制类型转换,此种转换要求开发者对实际参数类型预知的情况下进行,对于强制转换错误的情况,编译器可能不会提示错误,但在运行时会出现异常,这是一个安全隐患。
举例：不使用泛型实现参数化类型
1 package generic; 2 3 public class NoGeneric { 4 private Object ob; //定义通用类型成员 5 public NoGeneric(Object ob) { 6 this.ob = ob; 7 } 8 public Object getOb() { 9 return ob; 10 } 11 public void setOb(Object ob) { 12 this.ob = ob; 13 } 14 public void showType() { 15 System.out.println("实际类型是:"+ob.getClass().getName()); 16 } 17 } 18 19 package generic; 20 21 public class NoGenericDemo { 22 23 public static void main(String[] args) { 24 // TODO 自动生成的方法存根 25 //定义类NoGener的一个Integer版本 26 NoGeneric intob = new NoGeneric(new Integer(66)); 27 intob.showType(); 28 int i = (Integer)intob.getOb(); 29 System.out.println("value="+ i); 30 System.out.println("-----------------------------"); 31 //定义类NoGeneric的一个String版本 32 NoGeneric strob = new NoGeneric(new String("hello")); 33 strob.showType(); 34 String s = (String)strob.getOb(); 35 System.out.println("value="+ s); 36 } 37 }
执行结果为:
实际类型是:java.lang.Integer value=66 ----------------------------- 实际类型是:java.lang.String value=hello
上面的实例有两点需要注意:首先如下语句
String s = (String)strob.getOb();
在使用时必须明确指定返回对象需要被强制转化的类型为String,否则无法编译通过;其次,由于intob和strob都属于NoGeneric的类型,假如执行如下语句
intob = strob;
此种赋值,语法上是合法的,而在语义上是错误的,对于这种情况,只有在运行时才会出现异常,使用泛型就不会出现上述错误,泛型的好处就是在编译期 检查类型,捕捉类型不匹配错误,并且所有强制转换都是自动和隐式的,提高代码的重用率.
举例 2:使用泛型使用泛型实现参数实例化类型
package generic; public class Generic<T> { private T ob; //定义泛型成员变量 public Generic(T ob) { this.ob = ob; } public T getOb() { return ob; } public void setOb(T ob) { this.ob = ob; } public void showType() { System.out.println("实例类型为:" + ob.getClass().getName()); } } package generic; public class GenericDemo { public static void main(String[] args) { // TODO 自动生成的方法存根 //定义泛型Generic的一个Integer的版本 Generic<Integer> intob = new Generic<Integer>(88); intob.showType(); int i = intob.getOb(); System.out.println("value=" + i); System.out.println("----------------------"); //定义泛型Generic的一个String版本 Generic<String> strob = new Generic<String>("hello"); strob.showType(); String s = strob.getOb(); System.out.println("value=" + s); } }
运行结果为:
实例类型为:java.lang.Integer value=88 ---------------------- 实例类型为:java.lang.String value=hello
在引入泛型的前提下,如果再次执行
intob = strob;
将提示错误,编译无法通过
二、泛型定义
泛型的语法可归纳为
class class-name <type-param-list>{//......}
实例化泛型的语法为:
class-name <type-param-list> obj = new class-name<type-param-list>(cons-arg-list);
type-param-list用于指明当前泛型类可接受的类型参数占位符的个数; 如:
class Generic<T>{//......}
这里的T是类型参数的名称,并且只允许传一个类型参数给Generic类,在创建对象时,T用作传递 给Generic的实际类型的占位符,每当声明类型参数时,只需用目标类型替换T即可. 如:
Generic <Integer> intob;
声明对象时占位符T用于指定实际类型,如果传递实际类型为Integer,属性ob就是Integer类型,类型T还可以指定方法的返回类型 如:
public T getOb(){ return ob; }
理解泛型有三点需要注意:
1、泛型的类型参数只能为类类型（包括自定义类），不能是基本数据类型。
2、同一种泛型可以对应多个版本（因为类型参数时不确定的）、不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
注意 根据惯例,泛型类定义时通常使用一个唯一的大写字母表示一个类型参数.
三、有界类型
定义泛型类时,可以向类型参数指定任何类型信息,特别是集合框架操作中,可以最大限度地提高适用范围,但有时候需要对类型参数的取值进行一定程度的限制,以使数据具有可操作性.
为了处理这种情况,java提供了有界类型,.在指定类型参数时可以使用extends关键字限制此类型参数代表的类必须是继承自指定父类或父类本身.
使用extends关键字实现有界类型泛型类的定义
package generic; public class BoundGeneric<T extends Number> { //定义泛型数组 T[] array; public BoundGeneric(T[] array) { this.array = array; } //计算总和 public double sum() { double sum = 0.0; for(T t : array) { sum = sum + t.doubleValue(); } return sum; } }
BoundGeneric类的定义中,使用extends将T的类型限制为Number类及其子类,故可以再定义过程中调用Number类的doubleValue方法,现在分别指定Integer,double,String类型作为类型参数,测试BoundGeneric:
package generic; public class BoundGenericDemo { public static void main(String[] args) { // TODO 自动生成的方法存根 //使用整形数组构造泛型对象 Integer[] intArray = {1, 2, 3, 4}; BoundGeneric<Integer> iobj = new BoundGeneric<Integer>(intArray); System.out.println("iobj的和为:" + iobj.sum()); //使用Double型数组构造泛型对象 Double[] douArray = {1.2, 2.3, 3.4, 4.5}; BoundGeneric<Double> dobj = new BoundGeneric<Double>(douArray); System.out.println("dobj的和为:" + dobj.sum()); String[] strArray = {"str1","str2"}; //下面的语句将会报错,String不是Number的子类 //BoundGeneric<String> sobj = new BoundGeneric<String>(strArray); } }
运行结果为:
iobj的和为:10.0
dobj的和为:11.4
注:在使用extends(如:T extends someClass)声明的泛型类进行实例化时允许传递的参数类型为:如果someClass是类,可以传递someClass本身及其子类;如果someClass接口可以传递实现接口的类
四、通配符
首先在说通配符之前先看一下这段代码:使用前面定义的Generic类.
package generic; public class WildcarDemo { public static void func(Generic <Object> g) { //... } public static void main(String args[]) { Generic <Object> obj = new Generic<Object>(12); func(obj); Generic<Integer> iobj = new Generic<Integer>(12); //这里讲产生一个错误:类型 WildcarDemo 中的方法 func（Generic<Object>）对于参数（Generic<Integer>）不适用 //func(iobj); } }
上述代码的func()方法的创建意图是能够处理各种类型参数的Generic对象,因为Generic是泛型,所以在使用时需要为其指定具体的参数化类型Object,看似不成问题,
但在
func(iobj);
处产生一个编译错误,因为func定义过程中以明确声明的Generic的类型参数为Object,这里试图将Generic<Integer>类型的对象传递给func()方法,类型不匹配导致编译错误.这种情况可以使用通配符解决.通配符由"?"来表示,它代表一个未知类型
package generic; public class WildcarDemo2 { public static void func(Generic <?> g) { //... } public static void main(String args[]) { Generic<Object> obj = new Generic<Object>(12); func(obj); Generic<Integer> iobj = new Generic<Integer>(12); func(iobj); } }
上述代码,在采用了通配符后语句将无误的编译,运行.
在通配符使用的过程中,也可通过extends关键字限定通配符的界定的类型参数的范围.
package generic; public class WildcarDemo3 { public static void func(Generic <? extends Number> g) { //... } public static void main(String args[]) { Generic<Object> obj = new Generic<Object>(12); //这里将产生一个错误:类型 WildcarDemo3 中的方法 func（Generic<? extends Number>）对于参数（Generic<Object>）不适用 //func(obj); Generic<Integer> iobj = new Generic<Integer>(12); func(iobj); } }
五、泛型的局限性
java并没有真正实现泛型,是编译器在编译的时候在字节码上做了手脚(称为擦除). 这种实现理念在成java泛型本身有很多漏洞, 为了避免这些问题java对泛型的使用上做了一些约束,但不可避免的还是有一些问题存在.多数的限制都是由类型擦除引起的.
1、泛型类型不能被实例化
public class Gen<T>{ T ob; public Gen(){ ob = new T(); } }
Gen<T>构造器是非法的,类型擦除将变量T替换成Object,但这段代码的本意肯定不是调用new Object().类似:如
public <T> T[]build (T[] a){ T [] array = new T[2];
//... }
类型擦除会让这个方法总是构造一个Object[2]数组,但是可以通过调用Class.newInstance和Array.newInstance方法,利用反射构造泛型对象和数组
2、数组
不能实例化数组如：
T[] vals; vals = new T[10];
因为T在运行时时不存在的,编译器无法知道实际创建那种类型的数据.
其次,不能创建一个类型特定的泛型引用的数组 如:
Gen<String> []arrays = new Gen<String>[100];
上面的代码会损害类型安全
如果使用通配符,就可以创建泛型类型的引用数组
Gen<?> []arrays = new Gen<?>[10];
3、怒能用类型参数替换基本类型
因为擦除类型后原先的类型参数被Object或者限定类型替换,而基本类型是不能被对象所存储的,可以使用基本类型的包装类来解决此问题
4、异常
不能抛出也不能捕获泛型类的异常对象,使用泛型类来扩展Throwable也是非法的. 如:
public class GenericException <T> extends Exception{ //泛型类无法继承Throwable }
不能再catch子句中使用类型参数,例如下面的方法将不能编译
public static <T extends Throwable> void doWork(Class<T> t) { try { //... }catch(Throwable realCause) { //... }
但是在异常声明时可以使用类型参数,如:
public static <T extends Throwable> void doWork(T t) throws T { try { //... }catch(Throwable realCause) { throw t; } }
5、静态成员
不能在静态变量或者静态方法中引用类型参数 如:
public class Gen<T>{ static T ob; static T getOb() { return ob; } }
这些均参考自“Java SE程序设计”，算是做个笔记，以后忘了可以翻阅一下，写在自己的随笔中，也希望可以帮助更多的人。如有侵权，请联系本人删除
标签：
版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有
- 国外程序员整理的Java资源大全（全部是干货） 2020-06-12
- 2020年深圳中国平安各部门Java中级面试真题合集（附答案） 2020-06-11
- 2020年java就业前景 2020-06-11
- 04.Java基础语法 2020-06-11
- Java--反射(框架设计的灵魂)案例 2020-06-11
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
