Java 泛型 ~ generics。

Java 泛型 ~ generics。

---

---

what。

Java 推出泛型之前，程序员可以构建一个元素类型为 Object 的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道每个数据的数据类型，否则很容易引发 ClassCastException。

Java 泛型（generics）是 jdk 5 引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。

泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数。

package com.geek.demo00;

import java.util.ArrayList;
import java.util.List;

/**
 * @author geek
 */
public class GenericsDemo {

    // Java 推出泛型之前，程序员可以构建一个元素类型为 Object 的集合，该集合能够存储任意的数据类型对象，而在使用该集合的过程中，需要程序员明确知道每个数据的数据类型，否则很容易引发
    // ClassCastException。

    // Java 泛型（generics）是 jdk 5 引入的一个新特性，泛型提供了编译时类型安全监测机制，该机制允许我们在编译时检测到非法的类型数据结构。
    // 泛型的本质就是参数化类型，也就是所操作的数据类型被指定为一个参数。

    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("java");
        list.add(1);
        list.add(true);
        for (int i = 0; i < list.size(); i++) {
            Object o = list.get(i);
            System.out.println("o = " + o);

            // Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
            // 运行期异常。
//            String s = (String) list.get(i);
//            System.out.println("s = " + s);
        }

        List<String> strings = new ArrayList<>();
//        strings.add(1)
        strings.add("a");
        strings.add("b");
        strings.add("c");

        for (int i = 0; i < strings.size(); i++) {
            // 直接用 String 类型接收，而不是 Object。
            String s = strings.get(i);
            System.out.println("s = " + s);
        }
    }

}

• 好处。

• 类型安全。
• 消除了强制类型转换。

---

泛型类。

class 类名称<泛型标识, 泛型标识, ...> {
	private 泛型标识 变量名;
	...
}

• 常用的泛型标识：T、E、K、V

package com.geek.demo00;

/**
 * 泛型类的定义。
 * T ~ 类型形参。创建对象时指定具体的数据类型。
 *
 * @author geek
 */
public class Generic<T> {

    // T ~ 由外部使用类时指定。
    private T key;

    public Generic() {
    }

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

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    @Override
    public String toString() {
        return "Generic{" +
                "key=" + key +
                '}';
    }

}

---

使用。

类名<具体的数据类型> 对象名 = new 类名<具体的数据类型>();

• jdk 1.7 以后，后面的 <> 中的具体的数据类型可以省略不写。

类名<具体的数据类型> 对象名 = new 类名<>();

package com.geek.demo00;

/**
 * @author geek
 */
public class GenericTest {

    public static void main(String[] args) {
        // 泛型类在创建对象时指定具体的数据类型。
        Generic<String> generic = new Generic<String>("a");
        String key1 = generic.getKey();
        System.out.println("key1 = " + key1);
        // a
        Class<? extends Generic> stringGenericClass = generic.getClass();
        System.out.println(stringGenericClass);
        // class com.geek.demo00.Generic

        Generic<Integer> integerGeneric = new Generic<>(100);
        Integer key2 = integerGeneric.getKey();
        System.out.println("key2 = " + key2);
        // 100
        Class<? extends Generic> integerGenericClass = integerGeneric.getClass();
        System.out.println(integerGenericClass);
        // class com.geek.demo00.Generic

        // 如果没有指定类型，将按 Object 类型操作。
        Generic objectGeneric = new Generic();
        objectGeneric.setKey(1);
        objectGeneric.setKey("a");
        System.out.println("objectGeneric = " + objectGeneric);
        Class<? extends Generic> objectGenericClass = objectGeneric.getClass();
        System.out.println(objectGenericClass);
        // class com.geek.demo00.Generic

        System.out.println(stringGenericClass == integerGenericClass);
        // true
        System.out.println(integerGeneric == objectGeneric);
        // false

        // 泛型类不支持基本类型。Type argument cannot be of primitive type
//        Generic<int> generic1 = new Generic<int>();
    }

}


/*
- 泛型类，如果没有指定具体的数据类型，默认操作类型是 Object。

- 泛型的类型参数只能是类类型，不能是基本数据类型。

- 泛型类型在逻辑上可以看成是多个不同的类型，但实际上是相同类型。
 */

---

注意事项。

• 泛型类，如果没有指定具体的数据类型，默认操作类型是 Object。

• 泛型的类型参数只能是类类型，不能是基本数据类型。

• 泛型类型在逻辑上可以看成是多个不同的类型，但实际上是相同类型。

---

eg.

package com.geek.demo01;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 模拟抽奖器。
 *
 * @author geek
 */
public class PrizeGetter<T> {

    private Random random = new Random();
    /**
     * 奖品。
     */
    private T prize;
    /**
     * 奖品集合。
     */
    private List<T> list = new ArrayList<>();

    /**
     * 添加奖品。
     *
     * @param prize
     */
    public void addPrize(T prize) {
        list.add(prize);
    }

    /**
     * 获取奖品。抽奖。
     *
     * @return
     */
    public T getPrize() {
        prize = list.get(random.nextInt(list.size()));
        return prize;
    }

}

package com.geek.demo01;

/**
 * @author geek
 */
public class Client {

    public static void main(String[] args) {
        // 创建抽奖器对象，指定数据类型。
        PrizeGetter<String> stringPrizeGetter = new PrizeGetter<>();
        String[] prizes = {"华为手机", "小米手机", "Mac Book"};
        // 抽奖池中填充奖品。
        for (String prize : prizes) {
            stringPrizeGetter.addPrize(prize);
        }
        // 抽奖。
        String prize = stringPrizeGetter.getPrize();
        System.out.println("恭喜您抽中了 " + prize);

        // ~ ~ ~ ~ ~ ~ ~
        System.out.println("~ ~ ~ ~ ~ ~ ~");

        PrizeGetter<Integer> integerPrizeGetter = new PrizeGetter<>();
        int[] intPrizes = {100, 1000, 10000};
        for (int intPrize : intPrizes) {
            integerPrizeGetter.addPrize(intPrize);
        }
        Integer prize1 = integerPrizeGetter.getPrize();
        System.out.println("恭喜您抽中了 " + prize1);
    }

}

---

泛型类派生子类。

• 子类也是泛型类，子类和父类的泛型类型要一致。

class ChildGeneric<T> extends Generic<T>

• 子类不是泛型类，父类要明确泛型的数据类型。

class ChildGeneric extends Generic<String>

• eg。

package com.geek.genericclass;

/**
 * 子类也是泛型类，子类和父类的泛型类型要一致。
 * 
 * @author geek
 */
public class Parent<E> {

    private E value;

    public E getValue() {
        return value;
    }

    public void setValue(E value) {
        this.value = value;
    }

}

package com.geek.genericclass;

/**
 * @author geek
 */
public class ChildFirst<T> extends Parent<T> {

    // T 要相同。
    // 也可以扩展。
//    public class ChildFirst<T, E, K> extends Parent<T> {

    @Override
    public T getValue() {
        return super.getValue();
    }

    @Override
    public void setValue(T value) {
        super.setValue(value);
    }

    // public class ChildFirst<T> extends Parent {
    // extends 时，如果父类没有指定泛型，默认 Object。
//    @Override
//    public Object getValue() {
//        return super.getValue();
//    }
//
//    @Override
//    public void setValue(Object value) {
//        super.setValue(value);
//    }

}

package com.geek.genericclass;

/**
 * @author geek
 */
public class Test {

    public static void main(String[] args) {
        Parent<String> childFirst = new ChildFirst<String>();
        childFirst.setValue("geek");
        String value = childFirst.getValue();
        System.out.println("value = " + value);
        // value = geek
    }

}

• 子类不是泛型类，父类要明确泛型的数据类型。

package com.geek.genericclass;

/**
 * 泛型类派生子类，子类不是泛型类时，父类要明确数据类型。
 *
 * @author geek
 */
public class ChildSecond extends Parent<Integer> {

    @Override
    public Integer getValue() {
        return super.getValue();
    }

    @Override
    public void setValue(Integer value) {
        super.setValue(value);
    }

}

//public class ChildSecond extends Parent {
//
//    @Override
//    public Object getValue() {
//        return super.getValue();
//    }
//
//    @Override
//    public void setValue(Object value) {
//        super.setValue(value);
//    }
//
//}

package com.geek.genericclass;

/**
 * @author geek
 */
public class Test {

    public static void main(String[] args) {

        ChildSecond childSecond = new ChildSecond();
        childSecond.setValue(100);
        Integer value1 = childSecond.getValue();
        System.out.println("value1 = " + value1);
        // value1 = 100
    }

}

---

泛型接口。

interface 接口名称<泛型标识, 泛型标识, ...> {
	泛型标识 方法名();
}

• 实现类不是泛型类，接口要明确数据类型。

package com.geek.genericinterface;

/**
 * 实现类不是泛型类，接口要明确数据类型。
 *
 * @author geek
 */
public class Apple implements IGeneric<String> {

    @Override
    public String getKey() {
        return "hello Generic.";
    }

}


 不指定泛型类型，默认 Object。
//public class Apple implements IGeneric {
//
//    @Override
//    public Object getKey() {
//        return null;
//    }
//
//}

package com.geek.genericinterface;

/**
 * @author geek
 */
public class Test {

    public static void main(String[] args) {
        Apple apple = new Apple();
        String key = apple.getKey();
        System.out.println("key = " + key);
        // key = hello Generic.
    }

}

• 实现类也是泛型类，实现类和接口的泛型要一致。

package com.geek.genericinterface;

/**
 * 实现类也是泛型类，实现类和接口的泛型要一致。
 *
 * @author geek
 */
public class Pear<T, E> implements IGeneric<T> {

    private T key;

    // 可以扩展。
    private E value;

    public Pear(T key, E value) {
        this.key = key;
        this.value = value;
    }

    @Override
    public T getKey() {
        return key;
    }

    public E getValue() {
        return value;
    }

}

package com.geek.genericinterface;

/**
 * @author geek
 */
public class Test {

    public static void main(String[] args) {

        Pear<String, Integer> pear = new Pear<>("count", 100);
        String key1 = pear.getKey();
        Integer value = pear.getValue();
        System.out.println("key1 = " + key1);
        System.out.println("value = " + value);
        // key1 = count
        //value = 100
    }

}

---

泛型方法。

• 泛型类，是在实例化类的时候指定泛型的具体类型。

• 泛型方法，是在调用方法的时候指定泛型的具体类型。

修饰符<T, E, ...> 返回值类型 方法名(参数列表) {
	方法体...
}

• public 与返回值中间的 <T> 非常重要，可以理解为声明此方法为泛型方法。

• 只有声明了 <T> 的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法 。

• <T> 表明该方法将使用泛型类型，此时才可以在方法中使用泛型类型 T。

• 与泛型类的定义一样，此处 T 可以随便写为任意标识，常见的如 T、E、K、V 等形式的参数常用于表示泛型。

package com.geek.demo01;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

/**
 * 模拟抽奖器。
 *
 * @author geek
 */
public class PrizeGetter<T> {

    private Random random = new Random();
    /**
     * 奖品。
     */
    private T prize;
    /**
     * 奖品集合。
     */
    private List<T> list = new ArrayList<>();

    /**
     * 添加奖品。
     *
     * @param prize
     */
    public void addPrize(T prize) {
        list.add(prize);
    }

    /**
     * 获取奖品。抽奖。
     *
     * @return
     */
    public T getPrize() {
        prize = list.get(random.nextInt(list.size()));
        return prize;
    }

    /**
     * 泛型方法。
     *
     * @param list 参数。
     * @param <E>  泛型标识。具体类型在调用方法时决定。
     * @return
     */
    public <E> E getProduct(List<E> list) {
        return list.get(random.nextInt(list.size()));
    }

}

package com.geek.genericmethod;

import com.geek.demo01.PrizeGetter;

import java.util.ArrayList;
import java.util.List;

/**
 * @author geek
 */
public class Test {

    public static void main(String[] args) {
        PrizeGetter<Integer> integerPrizeGetter = new PrizeGetter<>();
        List<String> list = new ArrayList<>();
        list.add("笔记本");
        list.add("手机");
        list.add("扫地机器人");
        // 泛型方法的调用。类型在调用方法时传递。
        String product = integerPrizeGetter.getProduct(list);
        System.out.println("product = " + product);
        String name = product.getClass().getName();
        System.out.println("name = " + name);
        String simpleName = product.getClass().getSimpleName();
        System.out.println("simpleName = " + simpleName);
        // product = 笔记本
        //name = java.lang.String
        //simpleName = String

        // ~ ~ ~ ~ ~ ~ ~
        System.out.println("~ ~ ~ ~ ~ ~ ~");

        List<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);
        integers.add(3);
        // 泛型方法的调用。类型在调用方法时传递。
        Integer product1 = integerPrizeGetter.getProduct(integers);
        System.out.println("product1 = " + product1);
        String name1 = product1.getClass().getName();
        System.out.println("name1 = " + name1);
        String simpleName1 = product1.getClass().getSimpleName();
        System.out.println("simpleName1 = " + simpleName1);
        // product1 = 3
        //name1 = java.lang.Integer
        //simpleName1 = Integer
    }

}

注意：

    /**
     * 泛型方法。
     *
     * @param list 参数。
     * @param <E>  泛型标识。具体类型在调用方法时决定。
     * @return
     */
//    public <E> E getProduct(List<E> list) {
//        return list.get(random.nextInt(list.size()));
//    }

    // 如果和 public class PrizeGetter<T> { 的 <T> 相同，也不影响。
    // （这里的 T 和 PrizeGetter<T> 不同。）
    public <T> T getProduct(List<T> list) {
        return list.get(random.nextInt(list.size()));
    }

---

静态泛型方法。

    /**
     * 静态泛型方法，采用多个泛型类型。
     *
     * @param t
     * @param e
     * @param k
     * @param <T>
     * @param <E>
     * @param <K>
     */
    public static <T, E, K> void printType(T t, E e, K k) {
        System.out.println("t = " + t);
        System.out.println(t + " ~ " + t.getClass());
        System.out.println("e = " + e);
        System.out.println(e + " ~ " + e.getClass());
        System.out.println("k = " + k);
        System.out.println(k + " ~ " + k.getClass());
    }

    public static void main(String[] args) {
        // 调用多个泛型类型的静态泛型方法。
        PrizeGetter.printType(100, "java", true);
        // t = 100
        //100 ~ class java.lang.Integer
        //e = java
        //java ~ class java.lang.String
        //k = true
        //true ~ class java.lang.Boolean
    }

---

泛型方法 & 可变参数。

    /**
     * 泛型 ~ 可变参数。
     *
     * @param e
     * @param <E>
     */
    public static <E> void print(E... e) {
        for (E e1 : e) {
            System.out.println("e1 = " + e1);
        }
    }

    public static void main(String[] args) {
        // 调用泛型可变参数。
        print(1, "2", true, 4, 5);
        // e1 = 1
        //e1 = 2
        //e1 = true
        //e1 = 4
        //e1 = 5
    }

• 泛型方法使方法独立于类而产生变化。

• 如果 static 方法要使用泛型能力，就必须使其成为泛型方法。

---

类型通配符。

• 类型通配符一般是使用 ? 代替具体的类型实参。

• 所以，类型通配符是类型实参，而不是类型形参。

package com.geek.globbing;

/**
 * 类型通配符。
 *
 * @author geek
 */
public class Glob<E> {

    private E first;

    public E getFirst() {
        return first;
    }

    public void setFirst(E first) {
        this.first = first;
    }

}

package com.geek.globbing;

/**
 * @author geek
 */
public class Test {

    public static void main(String[] args) {
        Glob<Number> glob = new Glob<>();
        glob.setFirst(1);
        showGlob(glob);
    }

    public static void showGlob(Glob<Number> glob) {
        Number first = glob.getFirst();
        System.out.println("first = " + first);
    }

}

package com.geek.globbing;

/**
 * 通配符使用。
 *
 * @author geek
 */
public class Test {

    public static void main(String[] args) {
        Glob<Number> glob = new Glob<>();
        glob.setFirst(1);
        showGlob(glob);

        Glob<Integer> glob2 = new Glob<>();
        glob2.setFirst(2);

        // public final class Integer extends Number implements Comparable<Integer> {
        // 泛型传参 ~ 多态思想行不通。
        showGlob(glob2);

    }

//    public static void showGlob(Glob<Number> glob) {
//        Number first = glob.getFirst();
//        System.out.println("first = " + first);
//    }

    public static void showGlob(Glob<?> glob) {
        Object first = glob.getFirst();
        System.out.println("first = " + first);
    }

    // 'showGlob(Glob<Number>)' clashes with 'showGlob(Glob<Integer>)'; both methods have same erasure
    // 泛型类型不同，但 getClass(); 相同。不属于方法重载。
//    public static void showGlob(Glob<Integer> glob) {
//        Number first = glob.getFirst();
//        System.out.println("first = " + first);
//    }

}

---

类型通配符上限。

要求该泛型的类型，只能是该实参类型，或该实参类型的子类类型。

类/接口<? extends 实参类型>

package com.geek.globbing;

/**
 * 通配符上限使用。
 *
 * @author geek
 */
public class Test2 {

    public static void main(String[] args) {
        Glob<Number> glob = new Glob<>();
        glob.setFirst(1);
        showGlob(glob);

        Glob<Integer> glob2 = new Glob<>();
        glob2.setFirst(2);

        // public final class Integer extends Number implements Comparable<Integer> {
        // 泛型传参 ~ 多态思想行不通。
        showGlob(glob2);

    }

    // ? extends 上限。
    public static void showGlob(Glob<? extends Number> glob) {
        Number first = glob.getFirst();
        System.out.println("first = " + first);
    }

    // 使用 ?，还是返回 Object。
//    public static void showGlob(Glob<?> glob) {
//        Object first = glob.getFirst();
//        System.out.println("first = " + first);
//    }

}

注意。上限通配符不能填充数据。

package com.geek.globbing.up;

import java.util.ArrayList;
import java.util.List;

/**
 * @author geek
 */
public class TestUp {

    public static void main(String[] args) {
        List<Animal> animalList = new ArrayList<>();
        List<Cat> catList = new ArrayList<>();
        List<MiniCat> miniCatList = new ArrayList<>();

        // 泛型 上限 通配符。
        //传递的集合泛型类型只能是 Cat 或 Cat 的子类类型。
//        showAnimal(animalList);
        // Required type: List<? extends Cat>
        //Provided: List<Animal>
        showAnimal(catList);
        showAnimal(miniCatList);
    }

    /**
     * 泛型 上限 通配符。
     * 传递的集合泛型类型只能是 Cat 或 Cat 的子类类型。
     *
     * @param list
     */
    public static void showAnimal(List<? extends Cat> list) {
        // 上限通配符，不确定 List 能存数据的类型。以下三种均报错。
//        list.add(new Cat());
        // Required type: capture of ? extends Cat
        //Provided: Cat
//        list.add(new MiniCat());
//        list.add(new Animal())

        for (int i = 0; i < list.size(); i++) {
            Cat cat = list.get(i);
            System.out.println("cat = " + cat);
        }
    }

}

package com.geek.globbing.up;

/**
 * @author geek
 */
public class Animal {



}

package com.geek.globbing.up;

/**
 * @author geek
 */
public class Cat extends Animal {
}

package com.geek.globbing.up;

/**
 * @author geek
 */
public class MiniCat extends Cat {
}

---

类型通配符下限。

要求该泛型的类型，只能是该实参类型，或该实参类型的子类类型。

类/接口<? super 实参类型>

package com.geek.globbing.down;

import java.util.ArrayList;
import java.util.List;

/**
 * @author geek
 */
public class TestDown {

    public static void main(String[] args) {
        List<Animal> animalList = new ArrayList<>();
        List<Cat> catList = new ArrayList<>();
        List<MiniCat> miniCatList = new ArrayList<>();

        showAnimal(animalList);
        showAnimal(catList);
//        showAnimal(miniCatList);
        // Required type: List<? super Cat>
        //Provided:List<MiniCat>
    }

    /**
     * 泛型 下限 通配符。
     * 传递的集合泛型类型只能是 Cat 或 Cat 的子类类型。
     *
     * @param list
     */
    public static void showAnimal(List<? super Cat> list) {
        // 可以填充元素，但不保证元素数据类型的约束要求。
        list.add(new Cat());
        list.add(new MiniCat());

        for (Object o : list) {
            System.out.println("o = " + o);
        }
    }

}

---

jdk 中的使用 ~ TreeSet。

package com.geek.globbing.down;

import java.util.Comparator;
import java.util.TreeSet;

/**
 * @author geek
 */
public class TestTreeSet {

    public static void main(String[] args) {
//        TreeSet<Cat> treeSet = new TreeSet<>(new Comparator2());
        TreeSet<Cat> treeSet = new TreeSet<>(new Comparator1());
//        TreeSet<Cat> treeSet = new TreeSet<Cat>(new Comparator3());// 报错。
        treeSet.add(new Cat("Jerry", 20));
        treeSet.add(new Cat("Tom", 18));
        treeSet.add(new Cat("Geek", 25));
        for (Cat cat : treeSet) {
            System.out.println("cat = " + cat);
        }
    }

}


class Comparator1 implements Comparator<Animal> {

    @Override
    public int compare(Animal o1, Animal o2) {
        return o1.getName().compareTo(o2.getName());
    }

}

class Comparator2 implements Comparator<Cat> {

    @Override
    public int compare(Cat o1, Cat o2) {
        return o1.getAge() - o2.getAge();
    }

}

class Comparator3 implements Comparator<MiniCat> {

    @Override
    public int compare(MiniCat o1, MiniCat o2) {
        return o1.getLevel() - o2.getLevel();
    }

}

---

类型擦除。

泛型是 Java 1.5 版本才引进的概念，在这之前是没有泛型的，但是，泛型代码能够很好地和之前版本的代码兼容。那是因为，泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，我们称之为类型擦除。

package com.geek.type;

import java.util.ArrayList;
import java.util.List;

/**
 * 类型擦除。
 *
 * @author geek
 */
public class ErasureTest {

    public static void main(String[] args) {
        List<Integer> integerArrayList = new ArrayList<>();
        List<String> stringArrayList = new ArrayList<>();

        System.out.println("integerArrayList.getClass() = " + integerArrayList.getClass());
        System.out.println("stringArrayList.getClass() = " + stringArrayList.getClass());
        // integerArrayList.getClass() = class java.util.ArrayList
        //stringArrayList.getClass() = class java.util.ArrayList

        // 编译完本质上都是 ArrayList。
    }

}

无限制类型擦除。

package com.geek.type;

/**
 * 无限制类型擦除。
 *
 * @author geek
 */
public class Erasure<T> {

    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

}

package com.geek.type;

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

/**
 * 类型擦除。
 *
 * @author geek
 */
public class ErasureTest {

    public static void main(String[] args) {

        Erasure<Integer> erasure = new Erasure<>();
        Class<? extends Erasure> erasureClass = erasure.getClass();
        Field[] declaredFields = erasureClass.getDeclaredFields();
        for (Field declaredField : declaredFields) {
            System.out.println("declaredField = " + declaredField);
            System.out.println("declaredField.getName() = " + declaredField.getName() + " ~ declaredField.getType() = " + declaredField.getType());
        }
        // declaredField = private java.lang.Object com.geek.type.Erasure.key
        //declaredField.getName() = key ~ declaredField.getType() = class java.lang.Object
    }

}

---

有限制类型擦除。

package com.geek.type;

/**
 * 有限制类型擦除。
 *
 * @author geek
 */
public class Erasure<T extends Number> {

    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

}

package com.geek.type;

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

/**
 * 类型擦除。
 *
 * @author geek
 */
public class ErasureTest {

    public static void main(String[] args) {

        Erasure2<Integer> erasure2 = new Erasure2<>();
        Class<? extends Erasure2> erasure2Class = erasure2.getClass();
        Field[] declaredFields2 = erasure2Class.getDeclaredFields();
        for (Field declaredField : declaredFields2) {
            System.out.println("declaredField = " + declaredField);
            System.out.println("declaredField.getName() = " + declaredField.getName() + " ~ declaredField.getType() = " + declaredField.getType());
        }
        // declaredField = private java.lang.Number com.geek.type.Erasure2.key
        //declaredField.getName() = key ~ declaredField.getType() = class java.lang.Number
    }

}

---

类型擦除 ~ 方法参数。

package com.geek.type;

import java.util.List;

/**
 * 无限制类型擦除。
 *
 * @author geek
 */
public class Erasure<T> {

    private T key;

    public T getKey() {
        return key;
    }

    public void setKey(T key) {
        this.key = key;
    }

    /**
     * 泛型方法。
     *
     * @param t
     * @param <T>
     * @return
     */
    public <T extends List> T show(T t) {
        return t;
    }

}

package com.geek.type;

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

/**
 * 类型擦除。
 *
 * @author geek
 */
public class ErasureTest {

    public static void main(String[] args) {

        Erasure<Integer> erasure = new Erasure<>();

        Method[] declaredMethods = erasureClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            // 方法名和返回值类型。
            System.out.println(declaredMethod.getName() + " ~ " + declaredMethod.getReturnType());
        }
        // getKey ~ class java.lang.Object
        //show ~ interface java.util.List 类型擦除 上限类型 List。
        //setKey ~ void
    }

}

---

类型擦除 ~ 桥接方法。

package com.geek.type;

/**
 * 类型擦除 ~ 桥接方法。
 *
 * @author geek
 */
public interface Info<T> {

    T info(T t);

}

package com.geek.type;

/**
 * 类型擦除 ~ 桥接方法。
 *
 * @author geek
 */
public class InfoImpl implements Info<Integer> {

    @Override
    public Integer info(Integer integer) {
        return integer;
    }

}

package com.geek.type;

import java.lang.reflect.Method;

/**
 * @author geek
 */
public class InfoTest {

    public static void main(String[] args) {
        Class<InfoImpl> infoClass = InfoImpl.class;
        Method[] declaredMethods = infoClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod.getName() + " ~ " + declaredMethod.getReturnType());
        }
        // info ~ class java.lang.Integer
        //info ~ class java.lang.Object
    }

}

---

泛型 & 数组。

---