二十、JAVA中的泛型

1. 泛型概念

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable{}

public interface Deque<E> extends Queue<E> {}
public interface Queue<E> extends Collection<E> {}
public interface Collection<E> extends Iterable<E> {}

我们上面的代码中出现的<?>是什么东西呢 它叫泛型，常用来和集合对象一同使用，所以我们在开始学习集合之前，必须先了解下什么是泛型。而且泛型概念非常重要，它是程序的增强器，它是目前主流的开发方式。

泛型是（Generics）是JDK1.5 的一个新特性，其实就是一个“语法糖”，本质上就是编译器为了提供更好的可读性而提供的一种小手段，小技巧，虚拟机层面是不存在所谓“泛型”的概念的。

2. 作用

• 通过泛型的语法定义，约束集合元素的类型，进行安全检查，把错误显示在编译期

• 代码通用性更强。

• 泛型可以提升程序代码的可读性，但它只是一个语法糖（编译后这样的东西就被删除，不出现在最终的源代码中），对于JVM运行时的性能是没有任何影响的。

3. 泛型示例

我们创建一个ArrayList，上面看到eclipse提示有个黄线，什么意思呢？

ArrayList is a raw type. References to generic type ArrayList<E> should be parameterized.

ArrayList使用了泛型，在声明时需指定具体的类型。

那我们把这个<>里的方式就称为泛型。上面的泛型有什么作用呢？就是在编译阶段就检查我们传入的参数类型是否正确。

有了泛型，我们可以看到人家要求存放String，而故意存放的整数100，所以eclipse提示我们错误：

The method add(int, String) in the type List<String> is not applicable for the arguments (int)。

类型List的add方法要求增加的类型为String类型，不正确不能存入。

4. 泛型声明

泛型可以在接口、方法、返回值上使用：

java.util.List泛型接口/类：

public interface Collection<E> {}

泛型方法的声明：

public <E> void print(E e) {}

在方法返回值前声明了一个表示后面出现的E是泛型，而不是普通的java变量。

5. 常用名称

E - Element (在集合中使用，因为集合中存放的是元素)

T - Type（Java 类）

K - Key（键）

V - Value（值）

N - Number（数值类型）

? - 表示不确定的java类型

6. 案例 编译时类型检查

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
public class Test1 {
    public static void main(String[] args) {
       int[] a = new int[3];
       a[0]=1;
       a[1]=2;
       //int类型的数组，规定了数组里的数据类型，类型不对就报错。
//     a[2]="hello";
      
       //1，泛型的标志<>
       //2，泛型的好处：规定了数据的类型，不能想放什么数据就放什么类型，要遵守泛型规定的类型
       //3，泛型的数据类型只能是引用类型，不能是基本类型
       List<Integer> list = new ArrayList<Integer>();
       list.add(1);
       list.add(2);
//4，如果类型不对，把运行时期才会 报的错ClassCastException直接在编译时期就报出来
//     list.add("a");
//     list.add('b');
      
      //迭代器
       Iterator it = list.iterator();
       while(it.hasNext()) {
           Integer s = (Integer) it.next();
           System.out.println(s);
       }
      
    }
}

7. 案例 代码通用性更强

传统方式通过重载多态实现，方法同名，参数类型不同。

public class TestOldStyle {
    public static void print(Integer[] dArray) {
       for( Integer d : dArray) {
           System.out.println(d);
       }
    }
   
    public static void print( String[] sArray) {
       for( String s : sArray) {
           System.out.println(s);
       }
    }
   
    public static void main(String[] args) {
       Integer[] scores = new Integer[]{100,98,80};
       String[] names = new String[]{"语文","数学","英语"};
      
       TestOldStyle.print(scores);
       TestOldStyle.print(names);
    }
}

泛型方式

public class TestGenarics {

public static <E> void print(E[] arr) {

   for(E e : arr) {

       System.out.println(e);

   }

}



public static void main(String[] args) {

   Integer[] scores = new Integer[]{ 100,98,80 };

   String[] names = new String[]{ "语文","数学","英语" };

   Double[] moneys = new Double[] { 10.1,20.2,30.3 };

  

   TestGenarics.print(scores);

   TestGenarics.print(names);

   TestGenarics.print(moneys);

}

}

8. 案例 类型擦除

泛型只是在编译期间生存，编译后就被干掉了，真正运行时，大多情况下取而代之的是Object。

下面的代码利用了jdk提供的强大的反射功能。

 
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
 
//泛型类型擦除
public class TestGenerics {
    public static void main(String[] args) throws Exception {
       List<Integer> list = new ArrayList<Integer>();
     
       //1. 编译器按泛型检查，类型报错。这是在编译阶段
       //list.add("chenzs");
      
       //2. 但在实际运行时，泛型的地方就被替代为通用类型Object
       Class<?> clazz = list.getClass();
       Method m = clazz.getDeclaredMethod("add", Object.class);
      
       //3. 利用反射得到的对象是运行时对象，其就可以设置非整形的数据
       m.invoke(list, "chenzs");
      
      
       System.out.println(list.get(0));
    }
}