• 创造一个泛型类

// 泛型类
class MyArraylist<E> {
    private Object[] objs = new Object[10];
    private int size = 0;

    public void add(E e) {
        objs[size] = e;
        size++;
    }
    public E get(int index) {
        return (E) objs[index];
    }

    @Override
    public String toString() {
        return Arrays.toString(objs);
    }
}

• 创造一个泛型方法

class ListUtil{
    private ListUtil(){};
    public static<E> void addAll(ArrayList<E> list, E...e) {
        for(E element: e) {
            list.add(element);
        }
    }
}

• 调用泛型类和泛型方法

public class Generic {
    @Test
    public void test1() {
        MyArraylist<String> list = new MyArraylist<>();
        list.add("1234");
        list.add("84848");
        list.add("92929");
        System.out.println(list);
    }
    @Test
    public void test2() {
        ArrayList<String> list = new ArrayList<>();
        ListUtil.addAll(list, "123", "34234");
        System.out.println(list);
    }
}

• 泛型通配符

/* 泛型的通配符
    泛型不具备继承性，而数据具备继承性。
    为了限定泛型值特定的类型，因此要使用泛型的通配符
    ? extends Ye， 限定这个泛型是Ye，或者他的儿子
    ? super Zi, 限定这个泛型是Zi，或者他的父亲
 */
class Ye{}
class Fu extends Ye{}
class Zi extends Fu{}

public class Generic02 {
    @Test
    public void main(){
        ArrayList<Ye> list1 = new ArrayList<>();
        ArrayList<Fu> list2 = new ArrayList<>();
        ArrayList<Zi> list3 = new ArrayList<>();
        method(list1);
        method(list2);
        method(list3);
    }
    public void method(ArrayList<? extends Ye> list) {
        System.out.println(list);
    }
}

// 普通变量使用泛型的继承
public static <E extends Cat> void method1(E e) {
      System.out.println(e);
  }

• 泛型擦除

  当java代码通过了编译器之后，泛型就变成了第一个限行的类型，如果没有限定就是Object类型

  • 缺点：
  • 不能使用基本类型实例化参数，没有Pair<double>因为泛型擦除之后，object不能存储double
  • 运行时不能进行类型判断 if(a instanceof Pair<String>) // Error
  • 等等还有很多因为泛型擦除导致的问题

• 泛型和反射

  • String.class实际上是Class<String>的对象