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;
    }
}

public class Genericity<T> {
    private  T t;
    public Genericity(T t){
        this.t =t;
    }

    public T getT(){
        return  this.t;
    }
}
public class application {
    public static void main(String[] args) {
        //泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
        Genericity<Integer> integerGenericity = new Genericity<Integer>(123456);
        Genericity<String> stringGenericity = new Genericity<String>("abcdef");
        System.out.println(stringGenericity.toString());
        //如果不传入泛型类型实参的话，在泛型类中使用泛型的方法或成员变量定义的类型可以为任何的类型。
        Genericity genericity = new Genericity("xxxx");
        Genericity genericity1 = new Genericity(11111);

        System.out.println(genericity.getT());
        System.out.println(genericity1.getT());
    }
}

注意

1、泛型类的类型参数只能是类类型，不能是简单类型。

2、不能对不确定类型使用instanceof，在编译阶段会报错

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中

//定义泛型接口
public interface GenericityInterface<T> {
    public  T next();
}
//继承泛型接口时，传入泛型实参。
public class GenericitySub implements GenericityInterface<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    public String next() {
        Random random = new Random();
        return fruits[random.nextInt(3)];
    }
}

泛型通配符

解决实际相同类型，但做为方法形参时，会导致编译时报错问题(不同版本的泛型类实例是不兼容的)。

类型通配符一般是使用**？**

此处’？’是类型实参，而不是类型形参 。

public void showKeyValue1(Generic<?> obj){
    System.out.println("泛型测试","key value is " + obj.getKey());
}

泛型方法

泛型类，是指实例化该类时，确定调用类型，泛型方法，是指调用了该类方法时，才确定具体类型

public  <E> E getInstance(E t){
    E instance = t ;
    return instance;
}

注意：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法

    /**
     * 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
     * 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
     * 如：public static void show(T t){..},此时编译器会提示错误信息：
          "StaticGenerator cannot be refrenced from static context"
     */
    public static <T> void show(T t){

    }

泛型上下边界(只能让其父类或子类传入)

在使用泛型的时候，还可以为传入的泛型类型实参进行上下边界的限制。

如：类型实参只准传入某种类型的父类或某种类型的子类。

为泛型添加上边界，即传入的类型实参必须是指定类型的子类型

public void showKeyValue1(Generic<? extends Number> obj){
    Log.d("泛型测试","key value is " + obj.getKey());
}
Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

//这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
//showKeyValue1(generic1);

showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);

public class Generic<T extends Number>{
    private T key;

    public Generic(T key) {
        this.key = key;
    }

    public T getKey(){
        return key;
    }
}
//这一行代码也会报错，因为String不是Number的子类
Generic<String> generic1 = new Generic<String>("11111");

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

总结：通过上面的两个例子可以看出：泛型的上下边界添加，必须与泛型的声明在一起