Java的泛型

          在学习Java时，如何减少代码的冗余，如何减少运行时抛异常和错误，这是在编程中需要经常去考虑的。同一个功能，使用不同的参数类型就可能出现错误，如何减少这类型的问题的发生，于是就可以想到Java泛型功能。使用泛型的好处有以下两点：

1、减少代码冗余：不同的参数类型执行相同的代码

2、降低使用错误：编译阶段发现问题，且调用时无需强制类型转换

1、泛型类和泛型接口定义

泛型类：参数化的类型

class GenericMethod1<T> { 
    private T data;

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

class GenericMethod2<T,K> { //多个泛型参数
    private T data;
    private K res;
    
    public GenericMethod2(){}

    public K getRes() {
        return res;
    }

    public void setRes(K res) {
        this.res = res;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }
}

GenericMethod1<String> gen = new GenericMethod1<> ();

gen.setData("abc");

System.out.println(gen.getData());

泛型接口：

interface GenericInteface<T>{
    public T fun1();
}

类去实现泛型接口有两种方式：

//方法一：泛型接口在实现时，直接定义具体的类型
class ImpGenericMethod1 implements GenericInteface<String> {
    @Override
    public String fun1() {
        return null;
    }
}

//方法二：泛型接口在实现时，还是使用泛型（即泛型类实现泛型接口）
class ImpGenericMethod2<T> implements GenericInteface<T> {
    @Override
    public T fun1() {
        return null;
    }
}

2、泛型方法的辨析

识别方式：在访问范围和返回类型之间，有尖括号和模版的就是泛型方法。

class Gen{
    //泛型方法 （位置：不一定在泛型类或泛型接口里面）
    public <T> T genericMthod(T ...args){ //...可变参数的长度可变，args是一个数组
        return args[args.length/2];
    } 
}

Gen gen = new Gen();
gen.<String>genericMthod("abb","ccc", "ddd");
gen.genericMthod(1,2,3,"abc");

//泛型方法的使用

class GenericMethod3 <T>{
    public String fun(T a){ //正常函数
        return a.toString();
    }
    public <K> String fun1(K a){
        return a.toString();
    }
    
    public <K,T> K fun2(T a,K k){
        return k;
    }
    
    public class Fruit{
        @Override
        public String toString() {
            return "Fruit";
        }
    }
    
    public class Apple extends Fruit{
        @Override
        public String toString() {
            return "Apple";
        }
    }
    
    public class Person{
        @Override
        public String toString() {
            return "Perosn";
        }
    }
}

Apple apple = new Apple();
Person person = new Person();

GenericMethod3 <Fruit>  fru= new GenericMethod3<>();
fru.fun(apple);
fru.fun1(apple);
fru.fun1(person);

          GenericMethod3<T>和 public <T> T fun1(T a)的这两个T，可以不一样。因此可以fru.fun1(apple)和fru.fun1(person)都是正确的。fru.fun(person)这个是错误的。

总结：

1、不是声明在泛型类中的方法就是泛型方法

2、定义泛型方法时需要加尖括号和模板

3、在泛型类中定义的泛型方法中的模板可以不一样

3、限定类型变量

当我们传入一个模版参数，但是需要这个参数拥有某一个方法，此时可以使用extends派生，（即只能传入实现了某个方法的模板参数传入）。例如让模板参数有compareTo函数：

//extends 派生 类型变量的限定
class extendsClass{
    public static <T extends Comparable> T max(T a, T b){
        return a.compareTo(b) > 0 ? a : b;
    }
    //如果有类，则需要写在第一个。例如ArrayList，因为只能继承一个类，可实现多个接口
    public static <T extends ArrayList & Comparable> T min(T a, T b){
        return a.compareTo(b) > 0 ? a : b;
    }
}

4、泛型中的约束和局限性

1、不能够实例化类型变量

private class GenericProm<T>{

        private T data；

        public GenericProm(){

               this.data = new T();  报错

        }

}

2、静态方法或域不能引用类型变量（使用对象new之后，才知道泛型类型；而static静态是先执行，虚拟机都不认识引入的模板）如果静态方法本就是泛型方法，是可行的。

private class GenericProm<T>{

        private static T data； 报错

}

private class GenericProm<T>{

        private static T data； 

       private static <T> T getdata{...} ；正确

}

3、泛型的不允许double，int等基础类型作为模板参数，只允许包装类型Double、Integer等（可以理解double，int等都不是一个对象，Double、Integer等是的）

private class GenericProm<T>{...}

GenericProm<double> dd = new  GenericProm<>();错误

GenericProm<Gouble> dd = new  GenericProm<>();

4、泛型不能使用instanceof关键字

private class GenericProm<T>{...}

GenericProm<Gouble> dd = new  GenericProm<>();

if（dd Instanceof GenericProm<Gouble>） {...} 报错

if（dd Instanceof GenericProm<T>） {...} 报错

5、泛型无论传的什么参数，获取的类名都是一样的

private class GenericProm<T>{...}

GenericProm<Double> d = new GenericProm<>()；

GenericProm<Integer> i= new GenericProm<>()；

d.getClassName == i.getClassName ?  1:0; //一样 

6、可以定义泛型数组，却不能new一个泛型数组

private class GenericProm<T>{...}

GenericProm<T>[] = new GenericProm<>[5];  报错

7、泛型类不能extends Exception/Throwable

private class GenericProm<T> extends Exception;   报错

8、不能捕获泛型类对象，但可以抛出来

public<T extends Throwable> void fun(T t){

        try{

        }catch(T t){

                //todo    不能捕获

        }

}

public<T extends Throwable> void fun1(T t) throws T{

        try{

        }catch(Throwable e){

                throw t；    但能抛出来·

        }

}

5、泛型类型的继承规则

类的继承关系，不代表泛型后也存在继承关系

public class GenercClass<T> {
       public static void fun1(GenercClass<T> p){...}  
}

class Fruit{}

class Apple extends Fruit{}

class Hongfushi extends Apple{}

class Orange extends Fruit{}

GeneralClass <Fruit> a = new GenerClass<>();

fun1(a);

GeneralClass <Orange> b = new GenerClass<>();

fun1(b);

虽然Orange和Fruit是继承关系，但是a和b不存在继承关系。

GeneralClass <? extend Fruit> c = new GenerClass<>(); 就可以解决这个问题

6、通配符类型

？extends Fruit   通配符 ？extends 规定了上限，Fruit 是父，他的子类都可以；Fruit 的父类不能。可以安全的访问数据

public class GenercClass<T> {
       public static void fun1(GenercClass<？extends Fruit  > p){...}  
}

GenercClass<? extendT> x = new GenercClass<>(); 

？super Fruit       传进去的Fruit 的父类可以。Fruit子类不行。可以安全的写入数据

public class GenercClass<T> {
       public static void fun1(GenercClass<？super Fruit  > p){...}  
}

GenercClass<? super T> x = new GenercClass<>(); //x在setdata写入数据是只能是子类和自己，返回的getdata是Object超类

7、虚拟机是如何实现泛型的

类型擦除

public static void fun(List<String> A){...}
public static void fun(List<Integer> A){...}  //参数不一样，但是编译器会报错。泛型擦除后，编译器在泛型时根据方法名和参数去判断是否是同一个函数，JDK编译器会判断方法名，类名，参数去判断是否是同一个函数。

//如果有类，则需要写在第一个。例如ArrayList，因为只能继承一个类，可实现多个接口 public static <T extends ArrayList & Comparable> T min(T a, T b){

        return a.compareTo(b) > 0 ? a : b;

} 反编译可以看到，会进行强制类型转换