java泛型算是基础,整体都看过好多遍了,但是还是用的不熟悉,每次都不知道怎么写,后来思前想去,干脆死记硬背,这里记一下比较通用的写法。泛型分为::泛型类、泛型接口、泛型方法
泛型类:
//此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时,必须指定T的具体类型
public class Generic<T>{
//key这个成员变量的类型为T,T的类型由外部指定
private T key;
public Generic(T key) { //泛型构造方法形参key的类型也为T,T的类型由外部指定
this.key = key;
}
public T getKey(){ //泛型方法getKey的返回值类型为T,T的类型由外部指定
return key;
}
}
泛型类一般就这么定义就可以了,你想写其他逻辑也行,也不一定要把成员变量定义T由外部传入,但是如果你成员变量的类型写成T,那你就必须写成泛型类,如:
public class Generic<T>{
//key这个成员变量的类型为T,T的类型由外部指定
private String key;
public Generic(T key) {
//这里强转,或者你写其他处理逻辑都行
this.key = (String) key;
}
public String getKey(){ //泛型方法getKey的返回值类型为T,T的类型由外部指定
return key;
}
}
如果上面的属性或者方法有传入泛型,但是不定义泛型类,编译的时候就会报错如下是不允许的:
//编译报错
public class Generic{
//key这个成员变量的类型为T,T的类型由外部指定
private String key;
public T test(String key){
return null;
}
public String getKey(){ //泛型方法getKey的返回值类型为T,T的类型由外部指定
return key;
}
}
泛型接口
型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中,可以看一个例子:
//定义一个泛型接口
public interface Generator<T> {
public T next();
}
当实现泛型接口的类,未传入泛型实参时:
/**
* 未传入泛型实参时,与泛型类的定义相同,在声明类的时候,需将泛型的声明也一起加到类中
* 即:class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型,如:class FruitGenerator implements Generator<T>,编译器会报错:"Unknown class"
*/
class FruitGenerator<T> implements Generator<T>{
@Override
public T next() {
return null;
}
}
当实现泛型接口的类,传入泛型实参时:
/**
* 传入泛型实参时:
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
* 但是我们可以为T传入无数个实参,形成无数种类型的Generator接口。
* 在实现类实现泛型接口时,如已将泛型类型传入实参类型,则所有使用泛型的地方都要替换成传入的实参类型
* 即:Generator<T>,public T next();中的的T都要替换成传入的String类型。
*/
public class FruitGenerator implements Generator<String> {
private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}
泛型通配符
我们知道Ingeter是Number的一个子类,同时在特性章节中我们也验证过Generic与Generic实际上是相同的一种基本类型。那么问题来了,在使用Generic作为形参的方法中,能否使用Generic的实例传入呢?在逻辑上类似于Generic和Generic是否可以看成具有父子关系的泛型类型呢?
为了弄清楚这个问题,我们使用Generic这个泛型类继续看下面的例子:
public void showKeyValue1(Generic obj){
Log.d(“泛型测试”,"key value is " + obj.getKey());
}
复制代码
Generic gInteger = new Generic(123);
Generic gNumber = new Generic(456);
showKeyValue(gNumber);
// showKeyValue这个方法编译器会为我们报错:Generic<java.lang.Integer>
// cannot be applied to Generic<java.lang.Number>
// showKeyValue(gInteger);
复制代码
通过提示信息我们可以看到Generic不能被看作为`Generic的子类。由此可以看出:同一种泛型可以对应多个版本(因为参数类型是不确定的),不同版本的泛型类实例是不兼容的。
回到上面的例子,如何解决上面的问题?总不能为了定义一个新的方法来处理Generic类型的类,这显然与java中的多台理念相违背。因此我们需要一个在逻辑上可以表示同时是Generic和Generic父类的引用类型。由此类型通配符应运而生。
我们可以将上面的方法改一下:
public void showKeyValue1(Generic<?> obj){
Log.d(“泛型测试”,"key value is " + obj.getKey());
}
类型通配符一般是使用?代替具体的类型实参,注意了,此处’?’是类型实参,而不是类型形参 。重要说三遍!此处’?’是类型实参,而不是类型形参 ! 此处’?’是类型实参,而不是类型形参 !再直白点的意思就是,此处的?和Number、String、Integer一样都是一种实际的类型,可以把?看成所有类型的父类。是一种真实的类型。
可以解决当具体类型不确定的时候,这个通配符就是 ? ;当操作类型时,不需要使用类型的具体功能时,只使用Object类中的功能。那么可以用 ? 通配符来表未知类型。
泛型方法:
//此处T可以随便写为任意标识,常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时,必须指定T的具体类型
public class Generic<T>{
//key这个成员变量的类型为T,T的类型由外部指定
private String key;
public Generic(T key) {
//这里强转,或者你写其他处理逻辑都行
this.key = (String) key;
}
public String getKey(){ //泛型方法getKey的返回值类型为T,T的类型由外部指定
return key;
}
}
class TestFanxing{
//泛型通配符
public void showKeyValue1(Generic<?> obj){
System.out.println("aaa");;
}
public void mainaa() {
Generic<Integer> gInteger = new Generic<Integer>(123);
Generic<Number> gNumber = new Generic<Number>(456);
showKeyValue1(gNumber);
//泛型方法
say("ss");
TEXT("sss");
TEXT(111);
}
public static void main(String[] args) {
}
public <E> void say(E e){
}
public <E> E TEXT(E t){
return (E) new String("a");
}
}
可以看出格式就是
public <E> void say(E e){
}
public <E> E TEXT(E t){
return (E) new String("a");
}
泛型方法总结
泛型方法能使方法独立于类而产生变化,以下是一个基本的指导原则:
无论何时,如果你能做到,你就该尽量使用泛型方法。也就是说,如果使用泛型方法将整个类泛型化,
那么就应该使用泛型方法。另外对于一个static的方法而已,无法访问泛型类型的参数。
所以如果static方法要使用泛型能力,就必须使其成为泛型方法。
啥时候使用泛型通配符:
我自己就记住:当方法中传入泛型类的时候,这个泛型类中的类型又不确定是哪个参数,可以用?
如咱们的Generic;在方法中作为形参传入的时候: