1.5泛型

1.5泛型

1.概述

泛型，即“参数化 类型”。一提到参数，最熟悉的就是定义方法时有形参，然后调用此方法时传递实参。那么参数化类型怎么理解呢？顾名思义，就是将类型由原来的具体的类型参数化，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（类型实参）。

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的代码更改一下，编译器会在编译阶段就能够帮我们发现类似这样的问题。

List<String> arrayList = new ArrayList<String>();
...
//arrayList.add(100); 在编译阶段，编译器就会报错

3.特性

(1)泛型如果不指定则可以是任意类型

(2)泛型只能为引用类型不能是基本类型

(3)泛型只存在于编译阶段，不存在于运行阶段：类型擦除(伪泛型)

List<String> stringArrayList = new ArrayList<String>();
List<Integer> integerArrayList = new ArrayList<Integer>();

Class classStringArrayList = stringArrayList.getClass();
Class classIntegerArrayList = integerArrayList.getClass();

if(classStringArrayList.equals(classIntegerArrayList)){
    Log.d("泛型测试","类型相同");
}

//输出结果：泛型测试：类型相同

通过上面的例子可以证明，在编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。

对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的类型。

⭐如何获取到泛型：利用反射通过使用了泛型的方法或变量可以获取到

//1.获取到class对象，这个对象带有泛型T
//2.获取到class对象的方法或者属性，这个方法或者属性使用到了泛型T
//3.调用api获取
method.getGenericReturnType();
field.getGenericType()

---

4.泛型的使用

(1)泛型类

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
public class Generic<T> {

    private T key;

    /**
     * 当前方法并不是泛型方法
     * @return
     */
    public T getKey(){return key;}
    
    public Generic(T key) {
       this.key = key;
    }
    
    public Generic(){
    }

    public static void main(String[] args) {
        Generic<Integer> generic1 = new Generic<>(111);
        Generic<String> generic2 = new Generic<>("abc");
        Generic<?> generic3 = new Generic<>(22.22);
        
        //不能对确切的泛型类型使用instanceof操作。如下面的操作是非法的，编译时会出错。
        if(generic1 instanceof Generic<Number>){
           
        }
        
        //如果不指定类型，则可以是任意类型
        Generic generic4 = new Generic(66.6f);
    }
}

(2)泛型接口

public interface GenericInterface<T> {

    public T next();
}
//不指定泛型
class Apple implements GenericInterface{

    @Override
    public Object next() {
        return null;
    }
}
//如果加上<T> 则实现类也必须加上<T>
class Orange<T> implements GenericInterface<T>{

    @Override
    public T next() {
        return null;
    }
}
//传入泛型，实现类还可以接着定义自己的类型
class Watermelon<E> implements GenericInterface<String>{

    @Override
    public String next() {
        return "Watermelon";
    }
}

(3)泛型方法：<T>

只有用 修饰的才能叫做泛型方法(T也可以是E，K，V等其它字母)

如果泛型类中的静态方法要使用类的泛型，那么该静态方法一定要加上修饰

package learn01;

/**
 * @author zhangshiqin
 * @date 2022/1/14 - 16:34
 */
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
public class Generic<T> {

    private T key;

    /**
     * 当前方法并不是泛型方法
     * @return
     */
    public T getKey(){return key;}

    /**
     * 泛型方法的基本介绍
     * @param tClass 传入的泛型实参
     * @return T 返回值为T类型
     * 说明：
     *     1）public 与 返回值中间<t>非常重要，可以理解为声明此方法为泛型方法。
     *     2）只有声明了<t>的方法才是泛型方法，泛型类中的getKey()并不是泛型方法。
     *     3）<t>表明该方法将使用泛型类型t，此时才可以在方法中使用泛型类型t。
     *     4）与泛型类的定义一样，此处t可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
     *     5）这个返回值类型t，通过Class<t> tClass 这个参数传进来的t决定
     */
    public <t> t genericMethod(Class<t> tClass)throws InstantiationException , IllegalAccessException{
        return tClass.newInstance();
    }

    /**
     * 这个方法显然是有问题的，在编译器会给我们提示这样的错误信息"cannot reslove symbol E"
     * 因为在类的声明中并未声明泛型E，所以在使用E做形参和返回值类型时，编译器会无法识别。
     public E setKey(E key){
     this.key = keu
     }
     */

    /**
     * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' "
     * 虽然我们声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法。
     * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
     public <T> T showKeyName(Generic<E> container){
     ...
     }
     */

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

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

    public Generic(){
    }
}

(4)泛型通配符：？

通配符：？ 它是一个实参 ，匹配任意类型

如下，general和general2等价，不写也是代表匹配任意类型

public void general(Generic<?> args){

}

public void noGeneral(Generic<String> args){

}

public void general2(Generic args){

}

Generic<Integer> generic1 = new Generic<>(111);
Generic<String> generic2 = new Generic<>("abc");

generic2.general(generic1) //可以
generic2.noGeneral(generic1) //不可以  
generic2.general2(generic1); //可以    

(5)泛型上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

public void showKeyValue(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);

(2222);
Generic generic3 = new Generic(2.4f);
Generic generic4 = new Generic(2.56);

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

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