net网站开发找那家,玉溪市规划建设局网站,有做挂名法人和股东的网站吗,王悦做网站对java的泛型特性的了解仅限于表面的浅浅一层#xff0c;直到在学习设计模式时发现有不了解的用法#xff0c;才想起详细的记录一下。本文参考java 泛型详解、Java中的泛型方法、 java泛型详解
1. 概述
泛型在java中有很重要的地位#xff0c;在面向对象编程及各种设计模式…对java的泛型特性的了解仅限于表面的浅浅一层直到在学习设计模式时发现有不了解的用法才想起详细的记录一下。本文参考java 泛型详解、Java中的泛型方法、 java泛型详解
1. 概述
泛型在java中有很重要的地位在面向对象编程及各种设计模式中有非常广泛的应用。
什么是泛型为什么要使用泛型 泛型即“参数化类型”。一提到参数最熟悉的就是定义方法时有形参然后调用此方法时传递实参。那么参数化类型怎么理解呢顾名思义就是将类型由原来的具体的类型参数化类似于方法中的变量参数此时类型也定义成参数形式可以称之为类型形参然后在使用/调用时传入具体的类型类型实参。泛型的本质是为了参数化类型在不创建新的类型的情况下通过泛型指定的不同类型来控制形参具体限制的类型。也就是说在泛型使用过程中操作的数据类型被指定为一个参数这种参数类型可以用在类、接口和方法中分别被称为泛型类、泛型接口、泛型方法。 2. 一个栗子
一个被举了无数次的例子 List arrayList new ArrayList();
arrayList.add(aaaa);
arrayList.add(100);for(int i 0; i arrayList.size();i){String item (String)arrayList.get(i);Log.d(泛型测试,item item);
} 毫无疑问程序的运行结果会以崩溃结束
java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
ArrayList可以存放任意类型例子中添加了一个String类型添加了一个Integer类型再使用时都以String的方式使用因此程序崩溃了。为了解决类似这样的问题在编译阶段就可以解决泛型应运而生。
我们将第一行声明初始化list的代码更改一下编译器会在编译阶段就能够帮我们发现类似这样的问题。
ListString arrayList new ArrayListString();
...
//arrayList.add(100); 在编译阶段编译器就会报错
3. 特性
泛型只在编译阶段有效。看下面的代码 ListString stringArrayList new ArrayListString();
ListInteger integerArrayList new ArrayListInteger();Class classStringArrayList stringArrayList.getClass();
Class classIntegerArrayList integerArrayList.getClass();if(classStringArrayList.equals(classIntegerArrayList)){Log.d(泛型测试,类型相同);
} 输出结果D/泛型测试: 类型相同。
通过上面的例子可以证明在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型只在编译阶段有效。在编译过程中正确检验泛型结果后会将泛型的相关信息擦出并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说泛型信息不会进入到运行时阶段。
对此总结成一句话泛型类型在逻辑上看以看成是多个不同的类型实际上都是相同的基本类型。
4. 泛型的使用
泛型有三种使用方式分别为泛型类、泛型接口、泛型方法
4.3 泛型类
泛型类型用于类的定义中被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类如List、Set、Map。
泛型类的最基本写法这么看可能会有点晕会在下面的例子中详解
class 类名称 泛型标识可以随便写任意标识号标识指定的泛型的类型{private 泛型标识 /*成员变量类型*/ var; .....}
}
一个最普通的泛型类 //此处T可以随便写为任意标识常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时必须指定T的具体类型
public class GenericT{ //key这个成员变量的类型为T,T的类型由外部指定 private T key;public Generic(T key) { //泛型构造方法形参key的类型也为TT的类型由外部指定this.key key;}public T getKey(){ //泛型方法getKey的返回值类型为TT的类型由外部指定return key;}
} //泛型的类型参数只能是类类型包括自定义类不能是简单类型
//传入的实参类型需与泛型的类型参数类型相同即为Integer.
GenericInteger genericInteger new GenericInteger(123456);//传入的实参类型需与泛型的类型参数类型相同即为String.
GenericString genericString new GenericString(key_vlaue);
Log.d(泛型测试,key is genericInteger.getKey());
Log.d(泛型测试,key is genericString.getKey()); 12-27 09:20:04.432 13063-13063/? D/泛型测试: key is 123456
12-27 09:20:04.432 13063-13063/? D/泛型测试: key is key_vlaue
定义的泛型类就一定要传入泛型类型实参么并不是这样在使用泛型的时候如果传入泛型实参则会根据传入的泛型实参做相应的限制此时泛型才会起到本应起到的限制作用。如果不传入泛型类型实参的话在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
看一个例子 Generic generic new Generic(111111);
Generic generic1 new Generic(4444);
Generic generic2 new Generic(55.55);
Generic generic3 new Generic(false);Log.d(泛型测试,key is generic.getKey());
Log.d(泛型测试,key is generic1.getKey());
Log.d(泛型测试,key is generic2.getKey());
Log.d(泛型测试,key is generic3.getKey()); D/泛型测试: key is 111111
D/泛型测试: key is 4444
D/泛型测试: key is 55.55
D/泛型测试: key is false 注意
泛型的类型参数只能是类类型不能是简单类型。不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的编译时会出错。if(ex_num instanceof GenericNumber){ }
4.4 泛型接口
泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中可以看一个例子
//定义一个泛型接口
public interface GeneratorT {public T next();
}
当实现泛型接口的类未传入泛型实参时 /*** 未传入泛型实参时与泛型类的定义相同在声明类的时候需将泛型的声明也一起加到类中* 即class FruitGeneratorT implements GeneratorT{* 如果不声明泛型如class FruitGenerator implements GeneratorT编译器会报错Unknown class*/
class FruitGeneratorT implements GeneratorT{Overridepublic T next() {return null;}
} 当实现泛型接口的类传入泛型实参时 /*** 传入泛型实参时* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口GeneratorT* 但是我们可以为T传入无数个实参形成无数种类型的Generator接口。* 在实现类实现泛型接口时如已将泛型类型传入实参类型则所有使用泛型的地方都要替换成传入的实参类型* 即GeneratorTpublic T next();中的的T都要替换成传入的String类型。*/
public class FruitGenerator implements GeneratorString {private String[] fruits new String[]{Apple, Banana, Pear};Overridepublic String next() {Random rand new Random();return fruits[rand.nextInt(3)];}
} 4.5 泛型通配符
我们知道Ingeter是Number的一个子类同时在特性章节中我们也验证过GenericIngeter与GenericNumber实际上是相同的一种基本类型。那么问题来了在使用GenericNumber作为形参的方法中能否使用GenericIngeter的实例传入呢在逻辑上类似于GenericNumber和GenericIngeter是否可以看成具有父子关系的泛型类型呢
为了弄清楚这个问题我们使用GenericT这个泛型类继续看下面的例子
public void showKeyValue1(GenericNumber obj){Log.d(泛型测试,key value is obj.getKey());
} GenericInteger gInteger new GenericInteger(123);
GenericNumber gNumber new GenericNumber(456);showKeyValue(gNumber);// showKeyValue这个方法编译器会为我们报错Genericjava.lang.Integer
// cannot be applied to Genericjava.lang.Number
// showKeyValue(gInteger); 通过提示信息我们可以看到GenericInteger不能被看作为GenericNumber的子类。由此可以看出:同一种泛型可以对应多个版本因为参数类型是不确定的不同版本的泛型类实例是不兼容的。
回到上面的例子如何解决上面的问题总不能为了定义一个新的方法来处理GenericInteger类型的类这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时是GenericInteger和GenericNumber父类的引用类型。由此类型通配符应运而生。
我们可以将上面的方法改一下
public void showKeyValue1(Generic? obj){Log.d(泛型测试,key value is obj.getKey());
}
类型通配符一般是使用代替具体的类型实参注意了此处’’是类型实参而不是类型形参 。重要说三遍此处’’是类型实参而不是类型形参 此处’’是类型实参而不是类型形参 再直白点的意思就是此处的和Number、String、Integer一样都是一种实际的类型可以把看成所有类型的父类。是一种真实的类型。
可以解决当具体类型不确定的时候这个通配符就是 ? 当操作类型时不需要使用类型的具体功能时只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。
4.6 泛型方法
在java中,泛型类的定义非常简单但是泛型方法就比较复杂了。
尤其是我们见到的大多数泛型类中的成员方法也都使用了泛型有的甚至泛型类中也包含着泛型方法这样在初学者中非常容易将泛型方法理解错了。
泛型类是在实例化类的时候指明泛型的具体类型泛型方法是在调用方法的时候指明泛型的具体类型 。 /*** 泛型方法的基本介绍* param tClass 传入的泛型实参* return T 返回值为T类型* 说明* 1public 与 返回值中间T非常重要可以理解为声明此方法为泛型方法。* 2只有声明了T的方法才是泛型方法泛型类中的使用了泛型的成员方法并不是泛型方法。* 3T表明该方法将使用泛型类型T此时才可以在方法中使用泛型类型T。* 4与泛型类的定义一样此处T可以随便写为任意标识常见的如T、E、K、V等形式的参数常用于表示泛型。*/
public T T genericMethod(ClassT tClass)throws InstantiationException ,IllegalAccessException{T instance tClass.newInstance();return instance;
} Object obj genericMethod(Class.forName(com.test.test));
4.6.1 泛型方法的基本用法
光看上面的例子有的同学可能依然会非常迷糊我们再通过一个例子把我泛型方法再总结一下。 public class GenericTest {//这个类是个泛型类在上面已经介绍过public class GenericT{ private T key;public Generic(T key) {this.key key;}//我想说的其实是这个虽然在方法中使用了泛型但是这并不是一个泛型方法。//这只是类中一个普通的成员方法只不过他的返回值是在声明泛型类已经声明过的泛型。//所以在这个方法中才可以继续使用 T 这个泛型。public T getKey(){return key;}/*** 这个方法显然是有问题的在编译器会给我们提示这样的错误信息cannot reslove symbol E* 因为在类的声明中并未声明泛型E所以在使用E做形参和返回值类型时编译器会无法识别。public E setKey(E key){this.key keu}*/}/** * 这才是一个真正的泛型方法。* 首先在public与返回值之间的T必不可少这表明这是一个泛型方法并且声明了一个泛型T* 这个T可以出现在这个泛型方法的任意位置.* 泛型的数量也可以为任意多个 * 如public T,K K showKeyName(GenericT container){* ...* }*/public T T showKeyName(GenericT container){System.out.println(container key : container.getKey());//当然这个例子举的不太合适只是为了说明泛型方法的特性。T test container.getKey();return test;}//这也不是一个泛型方法这就是一个普通的方法只是使用了GenericNumber这个泛型类做形参而已。public void showKeyValue1(GenericNumber obj){Log.d(泛型测试,key value is obj.getKey());}//这也不是一个泛型方法这也是一个普通的方法只不过使用了泛型通配符?//同时这也印证了泛型通配符章节所描述的?是一种类型实参可以看做为Number等所有类的父类public void showKeyValue2(Generic? obj){Log.d(泛型测试,key value is obj.getKey());}/*** 这个方法是有问题的编译器会为我们提示错误信息UnKnown class E * 虽然我们声明了T,也表明了这是一个可以处理泛型的类型的泛型方法。* 但是只声明了泛型类型T并未声明泛型类型E因此编译器并不知道该如何处理E这个类型。public T T showKeyName(GenericE container){...} *//*** 这个方法也是有问题的编译器会为我们提示错误信息UnKnown class T * 对于编译器来说T这个类型并未项目中声明过因此编译也不知道该如何编译这个类。* 所以这也不是一个正确的泛型方法声明。public void showkey(T genericObj){}*/public static void main(String[] args) {}
} 4.6.2 类中的泛型方法
当然这并不是泛型方法的全部泛型方法可以出现杂任何地方和任何场景中使用。但是有一种情况是非常特殊的当泛型方法出现在泛型类中时我们再通过一个例子看一下 public class GenericFruit {class Fruit{Overridepublic String toString() {return fruit;}}class Apple extends Fruit{Overridepublic String toString() {return apple;}}class Person{Overridepublic String toString() {return Person;}}class GenerateTestT{public void show_1(T t){System.out.println(t.toString());}//在泛型类中声明了一个泛型方法使用泛型E这种泛型E可以为任意类型。可以类型与T相同也可以不同。//由于泛型方法在声明的时候会声明泛型E因此即使在泛型类中并未声明泛型编译器也能够正确识别泛型方法中识别的泛型。public E void show_3(E t){System.out.println(t.toString());}//在泛型类中声明了一个泛型方法使用泛型T注意这个T是一种全新的类型可以与泛型类中声明的T不是同一种类型。public T void show_2(T t){System.out.println(t.toString());}}public static void main(String[] args) {Apple apple new Apple();Person person new Person();GenerateTestFruit generateTest new GenerateTestFruit();//apple是Fruit的子类所以这里可以generateTest.show_1(apple);//编译器会报错因为泛型类型实参指定的是Fruit而传入的实参类是Person//generateTest.show_1(person);//使用这两个方法都可以成功generateTest.show_2(apple);generateTest.show_2(person);//使用这两个方法也都可以成功generateTest.show_3(apple);generateTest.show_3(person);}
} 4.6.3 泛型方法与可变参数
再看一个泛型方法和可变参数的例子
public T void printMsg( T... args){for(T t : args){Log.d(泛型测试,t is t);}
}
printMsg(111,222,aaaa,2323.4,55.55);
4.6.4 静态方法与泛型
静态方法有一种情况需要注意一下那就是在类中的静态方法使用泛型静态方法无法访问类上定义的泛型如果静态方法操作的引用数据类型不确定的时候必须要将泛型定义在方法上。
即如果静态方法要使用泛型的话必须将静态方法也定义成泛型方法 。 public class StaticGeneratorT {......../*** 如果在类中定义使用泛型的静态方法需要添加额外的泛型声明将这个方法定义成泛型方法* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。* 如public static void show(T t){..},此时编译器会提示错误信息StaticGenerator cannot be refrenced from static context*/public static T void show(T t){}
} 4.6.5 泛型方法总结
泛型方法能使方法独立于类而产生变化以下是一个基本的指导原则
无论何时如果你能做到你就该尽量使用泛型方法。也就是说如果使用泛型方法将整个类泛型化那么就应该使用泛型方法。另外对于一个static的方法而已无法访问泛型类型的参数。所以如果static方法要使用泛型能力就必须使其成为泛型方法。
4.6 泛型上下边界
在使用泛型的时候我们还可以为传入的泛型类型实参进行上下边界的限制如类型实参只准传入某种类型的父类或某种类型的子类。
为泛型添加上边界即传入的类型实参必须是指定类型的子类型
public void showKeyValue1(Generic? extends Number obj){Log.d(泛型测试,key value is obj.getKey());
} GenericString generic1 new GenericString(11111);
GenericInteger generic2 new GenericInteger(2222);
GenericFloat generic3 new GenericFloat(2.4f);
GenericDouble generic4 new GenericDouble(2.56);//这一行代码编译器会提示错误因为String类型并不是Number类型的子类
//showKeyValue1(generic1);showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4); 如果我们把泛型类的定义也改一下: public class GenericT extends Number{private T key;public Generic(T key) {this.key key;}public T getKey(){return key;}
} //这一行代码也会报错因为String不是Number的子类
GenericString generic1 new GenericString(11111);
再来一个泛型方法的例子 //在泛型方法中添加上下边界限制的时候必须在权限声明与返回值之间的T上添加上下边界即在泛型声明的时候添加
//public T T showKeyName(GenericT extends Number container)编译器会报错Unexpected bound
public T extends Number T showKeyName(GenericT container){System.out.println(container key : container.getKey());T test container.getKey();return test;
} 通过上面的两个例子可以看出泛型的上下边界添加必须与泛型的声明在一起 。
4.7 关于泛型数组要提一下
看到了很多文章中都会提起泛型数组经过查看sun的说明文档在java中是”不能创建一个确切的泛型类型的数组”的。
也就是说下面的这个例子是不可以的
ListString[] ls new ArrayListString[10];
而使用通配符创建泛型数组是可以的如下面这个例子
List?[] ls new ArrayList?[10];
这样也是可以的
ListString[] ls new ArrayList[10];
下面使用Sun的一篇文档的一个例子来说明这个问题 ListString[] lsa new ListString[10]; // Not really allowed.
Object o lsa;
Object[] oa (Object[]) o;
ListInteger li new ArrayListInteger();
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而不会出现异常但是在取出数据的时候却要做一次类型转换所以就会出现ClassCastException如果可以进行泛型数组的声明上面说的这种情况在编译期将不会出现任何的警告和错误只有在运行时才会出错。而对泛型数组的声明进行限制对于这样的情况可以在编译期提示代码有类型安全问题比没有任何提示要强很多。 下面采用通配符的方式是被允许的:数组的类型不可以是类型变量除非是采用通配符的方式因为对于通配符的方式最后取出数据是要做显式的类型转换的。 List?[] lsa new List?[10]; // OK, array of unbounded wildcard type.
Object o lsa;
Object[] oa (Object[]) o;
ListInteger li new ArrayListInteger();
li.add(new Integer(3));
oa[1] li; // Correct.
Integer i (Integer) lsa[1].get(0); // OK 5. 最后
本文中的例子主要是为了阐述泛型中的一些思想而简单举出的并不一定有着实际的可用性。另外一提到泛型相信大家用到最多的就是在集合中其实在实际的编程过程中自己可以使用泛型去简化开发且能很好的保证代码质量。
