泛型的初步理解

泛型的定义：

Java泛型(Generic)是J2 SE1.5中引入的一个新特性，其本质是参数化类型，也就是说所操作的数据类型被指定为一个参数（type parameter）这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
https://docs.oracle.com/javase/1.5.0/docs/guide/language/generics.html

泛型的使用

泛型和成员属性一样,需要先声明才能使用.泛型的声明采用 <> 进行声明.
申明一般约定采用单个大写字母表示.常用的有 K E T V 等等字符

1. 泛型类

/**
 * 类上的泛型可以是一个或者多个
 * 
 * @param <T>
 */
public class GenericClass<T> {

    private T first;

    private T second;

    public String getName(T t) {
        return "";
    }

}

2. 泛型方法
   实体方法可以使用在类中定义的泛型或者方法中定义的泛型
   静态方法不可以使用在类中定义的泛型,只能使用在静态方法上定义的泛型.

/**
 * 类上的泛型和方法上的泛型
 * 
 * @param <K>
 * @param <V>
 */
public class GenericMethod<K, V> {

    /**
     * 1、实体方法使用类上定义的泛型
     * 
     * @param k
     * @param v
     * @return
     */
    public K method1(K k, V v) {
        return null;
    }

    /**
     * 2、方法上定义泛型
     *
     * @return
     */
    public <T> T method02() {
        return null;
    }

    /**
     * 静态方法中不能直接使用类上定义的泛型 静态方法中可以使用方法上定义的泛型
     * 
     * @return
     */
    // public static V method03(){
    // return null;
    // }

    public static <P> P method04() {
        return null;
    }

}

3. 泛型接口

/**
 * 泛型接口定义
 *
 * @param <T>
 */
public interface CalGeneric<T> {

    T add(T a, T b);

    T sub(T a, T b);

    T mul(T a, T b);

    T div(T a, T b);
}

/**
 * 泛型接口实现
 */
public class DoubleCalc implements CalGeneric<Double> {

    @Override
    public Double add(Double a, Double b) {
        return a + b;
    }

    @Override
    public Double sub(Double a, Double b) {
        return null;
    }

    @Override
    public Double mul(Double a, Double b) {
        return null;
    }

    @Override
    public Double div(Double a, Double b) {
        return null;
    }

}

泛型通配符

无界通配符 ？
上界通配符 ？ extends Number
下界通配符 ？ Supper Integer

import java.util.ArrayList;

/**
 * 泛型通配符：边界的问题
 * 三种边界
 * 无界：？<?>
 * 上界： <? extends E>
 * 下界： <? super E>
 *
 *  编译检查 保证类型的安全
 *  避免强制转换的硬编码
 *  增加调用代码的重用性
 */
public class BorderDemo {

    /**
     * 无界通配符的使用
     */
    public void border01(ArrayList<?> arrayList) {
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(0));
        }
    }

    /**
     * 上界通配符的使用 <? extends Object> 无界通配符
     */
    public void border02(ArrayList<? extends Number> arrayList) {
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(0));
        }
    }

    /**
     * 下界通配符的使用
     */
    public void border03(ArrayList<? super Number> arrayList) {
        for (int i = 0; i < arrayList.size(); i++) {
            System.out.println(arrayList.get(0));
        }
    }

    public static void main(String[] args) {
        BorderDemo borderDemo = new BorderDemo();
        ArrayList<String> strList = new ArrayList<>();
        ArrayList<Object> objList = new ArrayList<>();
        ArrayList<Number> numberArrayList = new ArrayList<>();
        ArrayList<Double> doubleArrayList = new ArrayList<>();
        ArrayList<Integer> intArrayList = new ArrayList<>();

        // 无界
        borderDemo.border01(strList);
        borderDemo.border01(numberArrayList);
        borderDemo.border01(intArrayList);

        // 上界
        borderDemo.border02(numberArrayList);
        borderDemo.border02(doubleArrayList);
        // borderDemo.border02(strList); //泛型编译检查

        // 下界
        borderDemo.border03(objList);

    }
}

泛型的作用

Java泛型保障了类型的安全
避免了类型转换逻辑
提高代码的重用率

方方法桥接和类型擦除

1. 方法桥接
   JDK 1.5 引入泛型后，为了使Java的泛型方法生成的字节码和 1.5 版本前的字节码相兼容，由编译器自动生成的方法
   自动生成一个Object参数的方法：
   泛型类SuperClass

public interface SuperClass<T> {

    T m01(T param);

}

实现类：SubClass

public class SubClass implements SuperClass<String> {

    @Override
    public String m01(String param) {
        return param + "===";
    }

}

测试类BridgeMethodTest

package com.jw.javacore.generic.bridge;

public class BridgeMethodTest {

    public static void main(String[] args) {
        SuperClass subClass = new SubClass(); // 多态

        System.out.println(subClass.m01("123abc"));
        System.out.println(subClass.m01(new Object())); // m01(object)
    }

}

上述代码执行subClass.m01(new Object())时:
编译正常，因为编译器编译时给SubClass自动生成了一个参数为Object的方法m01(java.lang.Object)
运行失败，会抛出类型装换异常，使用javap命令查看字节码文件会发现存在上述m01(java.lang.Object)方法
javap -verbose SubClass.class

2. 泛型的的类型擦除
   泛型只在编译阶段有效,泛型类型在逻辑上可看成是多个不同的类型，但是其实质都是同一个数据类型；
   编译之后程序会采取去泛型化的措施
   也就是说Java泛型是假的，编译后的字节码文件是没有任何泛型信息的

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

import org.junit.Test;

/**
 * 泛型并不影响那个数据的基本类型； 伪泛型，Java编译期间会将泛型擦除
 */
public class GenType {

    @Test
    public void m01() {
        List list = new ArrayList();
        List<String> strList = new ArrayList<String>();

        System.out.println(list.getClass());
        System.out.println(strList.getClass());
        System.out.println(list.getClass() == strList.getClass()); // true
    }

    @Test
    public void method02() throws Exception {
        List<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        // list.add(1);
        System.out.println(list.size());
        System.out.println("-------------------------");

        Class<? extends List> clazz = list.getClass();
        Method m = clazz.getDeclaredMethod("add", Object.class);
        m.invoke(list, new Object());

        System.out.println(list.size());

    }

}

3. 堆污染
   当一个 可变泛型参数指向一个无泛型参数时，堆污染(Heap Pollution)就有可能发生
   也就是说，由于代码上没有限制，导致的类型乱入

import java.util.Set;
import java.util.TreeSet;

/**
 * 当一个可变泛型参数指向一个无泛型参数时，堆污染
 */
public class Pollution {

    public static void main(String[] args) {
        Set set = new TreeSet();
        // set.add("addd");
        varagMethod(set);
        set.add("abc");// 原先无泛型的Set已经被污染了，变成了可变泛型Integer
    }

    private static void varagMethod(Set<Integer> set) {
        set.add(new Integer(100));
        System.out.println(set.size());
    }

}