1. interface List{} , public class HashSet..等等
    • 说明:T,E只能是引用类型
    • List list = new ArrayList(); //OK
    • List list2 = new ArrayList();//报错！！！
    1. 在给泛型指定具体类型后,可以传入该类型或者其子类类型
    2. 泛型使用形式

    List list1 =new ArrayList();
    List list2 = new ArrayList<>();
    3．如果我们这样写 List list3 = new ArrayList(); 默认给它的泛型是[E就是Object ]即:

    1. package test;
    4. import java.util.ArrayList;
    5. import java.util.List;
    7. public class Main {
    8.     public static void main(String[] args) {
    9.         //1.给泛型指向数据类型是，要求是引用类型，不能是基本数据类型
    10.         List<Integer> list = new ArrayList<Integer>(); //OK
    11.         //List<int> list2 = new ArrayList<int>();//错误
    13.         //2. 说明
    14.         //因为 E 指定了 A 类型, 构造器传入了 new A()
    15.         //在给泛型指定具体类型后，可以传入该类型或者其子类类型
    16.         Pig<A> aPig = new Pig<A>(new A());
    17.         aPig.f();
    18.         Pig<A> aPig2 = new Pig<A>(new B());
    19.         aPig2.f();
    21.         //3. 泛型的使用形式
    22.         ArrayList<Integer> list1 = new ArrayList<Integer>();
    23.         List<Integer> list2 = new ArrayList<Integer>();
    24.         //在实际开发中，我们往往简写
    25.         //编译器会进行类型推断, 推荐使用下面写法
    26.         ArrayList<Integer> list3 = new ArrayList<>();
    27.         List<Integer> list4 = new ArrayList<>();
    28.         ArrayList<Pig> pigs = new ArrayList<>();
    30.         //4. 如果是这样写 泛型默认是 Object
    31.         ArrayList arrayList = new ArrayList();//等价 ArrayList<Object> arrayList = new ArrayList<Object>();
    33.         /*
    34.             public boolean add(Object e) {
    35.                 ensureCapacityInternal(size + 1);  // Increments modCount!!
    36.                 elementData[size++] = e;
    37.                 return true;
    38.             }
    39.          */
    40.         Tiger tiger = new Tiger();
    41.         /*
    43.             class Tiger {//类
    44.                 Object e;
    46.                 public Tiger() {}
    48.                 public Tiger(Object e) {
    49.                     this.e = e;
    50.                 }
    51.             }
    53.          */
    55.     }
    56. }
    57. class Tiger<E> {//类
    58.     E e;
    60.     public Tiger() {}
    62.     public Tiger(E e) {
    63.         this.e = e;
    64.     }
    65. }
    67. class A {}
    68. class B extends A {}
    70. class Pig<E> {
    71.     E e;
    73.     public Pig(E e) {
    74.         this.e = e;
    75.     }
    77.     public void f() {
    78.         System.out.println(e.getClass()); //运行类型
    79.     }
    80. }

    image.png