泛型

本质

参数化类型, 指定类型防止出现参数转化异常

泛型的擦除

只在编译阶段有效，编译之后jvm会采取去泛型化的措施。可以通过反射跳过泛型的检查。

public class Erase {

    public static void main(String[] args) throws Exception {
        List<String> stringList = new ArrayList<>();
        stringList.add("1");
        stringList.add("2");
        //直接添加会失败 编译不通过提示错误
        //stringList.add(new Object());

        //通过反射跳过编译添加object对象在list集合
        Class clas = stringList.getClass();
        Method method = clas.getDeclaredMethod("add", Object.class);
        method.invoke(stringList, new Object());

        System.out.println(stringList);
    }

}

通配符

无边界

public class NoBorder {

    //无边界通配符 可以任意传
    public static  void  test(List<?> list) {
        System.out.println(list.size());
    }

    public static void main(String[] args) {
        List<String> stringList = new ArrayList<>();
        test(stringList);
    }
}

上边界

public class UpBorder {
    //上边界通配符 必须是Number的子类
    public static void test(List<? extends  Number> list) {
        System.out.println(list.size());
    }

    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        test(numberList);
    }
}

下边界

public class DownBorder {

    //下边界通配符  必须是 number或者 number - object
    public static void test(List<? super Number> list) {
        System.out.println(list.size());
    }

    public static void main(String[] args) {
        List<Object> objects = new ArrayList<>();
        test(objects);
    }
}

规则

必须先声明在使用，泛型的声明是通过一对<>实现的，约定泛型可以使用单个大写字母来表示。比如说常见T E等字母并没有任何的意义只不过是泛型的声明罢了。

<span style='color:red'>错误,无声明</span>

public class Demo {
    //定义一个方法传入一个泛型参数，返回一个泛型的对象。因为这里没有声明报错
    public  H getName(H h) {
        return null;
    }
}

正确的写法

public <H> H getName(H h) {
    return null;
}

使用

泛型类

//声明
public class DemoClass<T> {
    private T getName;

    public T getGetName() {
        return getName;
    }

    public void setGetName(T getName) {
        this.getName = getName;
    }

    public static void main(String[] args) {
        //new的时候用<>指定泛型的类型
        DemoClass<String> demoClass = new DemoClass<>();
        demoClass.setGetName("Test");
    }
}

泛型方法

public  class GenericMethod <K,V> {

    //使用类中定义的泛型
    public K getName(K k,V v) {
        return (K) null;
    }
    //使用方法中定义的泛型
    public <T> T getName(K k) {
        return (T) k;
    }
    
    //静态方法无法使用类中定义的泛型，只能使用方法定义的泛型
    public static <K,V> K getName1(V v) {
        return (K) v;
    }
    
}

泛型接口

public interface GenericInterface<K,V> {

    public K getName(V v);
}
//实现了泛型接口的类 需要指定泛型的参数
public class GenericInterfaceImpl implements GenericInterface<String,Integer> {
    @Override
    public String getName(Integer integer) {
        return null;
    }
}