java泛型
1. 泛型的引出
首先，提出看下下面的代码：
package book.generic;
import java.util.List;
import org.junit.Test;
import java.util.ArrayList;
public class GenericDemo {
public static void main(String[] args) {
List list = new ArrayList();
list.add("qqym");
list.add("corm");
list.add(100);*/
for(int i = 0;i < list.size(); i++) {
String name = (String) list.get(i); //（1）此处会出现异常：java.lang.ClassCastException
System.out.println("name:" + name);
}
}
}定义了一个List集合，先向其中加入了两个字符串类型的值，随后加入了一个Interger类型的值。这是完全允许的，因此此时list默认的类型的Object类型。在随后的循环中，由于忘记了之前的list中也加入了Interger类型的值或其他类型的值，很容易出现（1）处的错误，导致类错误编码在编译时不易发现；
在上述的编码中我们主要发现了两处问题：
1、当我们将一个对象放入集合中，集合不会记住此对象的类型，当再次从集合中取出此对象时，该对象的编译类型变成了Object类型，但其运行时该类型仍然为其本身类型；
2、因此，（1）处取出集合元素时要进行类型的强制转化，这就很容易出现“java.lang.ClassCastException”异常；
这里，为了解决这个问题，使其运行时不会出现异常，答案就是：使用“泛型”；
2.什么是泛型
泛型，即“参数化类型”。顾名思义，就是将类型由原来的具体的类型参数化，类似于方法中的变量参数，此时类型也定义成参数形式（可以称之为类型形参），然后在使用/调用时传入具体的类型（实参类型）。
我们先看一下上面的例子用泛型的写法：
package book.generic;
import java.util.List;
import org.junit.Test;
import java.util.ArrayList;
public class GenericDemo {
public static void main(String[] args) {
/*List list = new ArrayList();
list.add("qqym");
list.add("corm");
list.add(100);
for(int i = 0;i < list.size(); i++) {
String name = (String) list.get(i); //此处会出现异常java.lang.ClassCastException
System.out.println("name:" + name);
}*/
List list = new ArrayList();
list.add("qqym");
list.add("corm");
//list.add(100); （1） 编译错误！！！
for(int i = 0;i < list.size(); i++) {
String name = list.get(i); //（2）此时不需要进行类型转换
System.out.println("name:" + name);
}
}
采用泛型后，在（1）处想加入一个Interger类型的对象时会出现编译错误，通过List,直接限定了List中只能含有String类型的元素，从而在（2）处无需进行类型转化，因此，集合能够记住元素的类型信息，编译器已经能够确认它是String类型了。
结合上面的泛型定义，我们知道在List类型中，String是实参类型，也就是说，相应的List接口中肯定含有类型形参。且get方法返回的结果也直接
是此类型（也就是传入的实参类型）。下面看一下List接口的具体定义：
public interface List<E> extends Collection<E> {
// Query Operations
int size();
boolean isEmpty();
boolean contains(Object o);
Iterator iterator();
Object[] toArray();
T[] toArray(T[] a);
boolean add(E e);
boolean remove(Object o);
boolean containsAll(Collection c);
boolean addAll(int index, Collection c);
boolean retainAll(Collection c);
default void replaceAll(UnaryOperator operator) {
Objects.requireNonNull(operator);
final ListIterator li = this.listIterator();
while (li.hasNext()) {
li.set(operator.apply(li.next()));
}
}
@SuppressWarnings({"unchecked", "rawtypes"})
default void sort(Comparatorsuper E> c) {
Object[] a = this.toArray();
Arrays.sort(a, (Comparator) c);
ListIterator i = this.listIterator();
for (Object e : a) {
i.next();
i.set((E) e);
}
}
boolean equals(Object o);
int hashCode();
E get(int index);
E set(int index, E element);
void add(int index, E element);
E remove(int index);
int indexOf(Object o);
ListIterator listIterator();
List subList(int fromIndex, int toIndex);
default Spliterator spliterator() {
return Spliterators.spliterator(this, Spliterator.ORDERED);
}
} 我们可以看到，E表示类型形参，可以接收具体的类型实参。
3.自定义泛型接口，泛型类和泛型方法
从上面的内容中，大家已经明白了泛型的具体运作过程。也知道了接口、类和方法也都可以使用泛型去定义，以及相应的使用。是的，在具体使用时，可以分为泛型接口、泛型类和泛型方法。
自定义泛型接口、泛型类和泛型方法与上述Java源码中的List、ArrayList类似。如下，我们看一个最简单的泛型类和方法定义：
package book.generic;
public class GenericOfselfDemo {
private T data;
public GenericOfselfDemo() {
}
public GenericOfselfDemo(T data) {
this.data = data;
}
public T getData() {
return data;
}
public static void main(String[] args) {
GenericOfselfDemo name = new GenericOfselfDemo("LIU");
System.out.println("name:" + name.getData());
}
}
在泛型接口、泛型类和泛型方法的定义过程中，我们常见的如T、E、K、V等形式的参数常用于表示泛型形参，由于接收来自外部使用时候传入的类型实参。那么对于不同传入的类型实参，生成的相应对象实例的类型是不是一样的呢？
package book.generic;
public class GenericOfselfDemo {
private T data;
public GenericOfselfDemo() {
}
public GenericOfselfDemo(T data) {
this.data = data;
}
public T getData() {
return data;
}
public static void main(String[] args) {
GenericOfselfDemo name = new GenericOfselfDemo("LIU");
GenericOfselfDemo num = new GenericOfselfDemo(123);
//System.out.println("name:" + name.getData());
System.out.println("name.class:" + name.getClass());
//name.class:class book.generic.GenericOfselfDemo
System.out.println("num.class:" + num.getClass());
//name.class:class book.generic.GenericOfselfDemo
System.out.println(name.getClass() == num.getClass());
//true
}
}
由此，我们发现，在使用泛型类时，虽然传入了不同的泛型实参，但并没有真正意义上生成不同的类型，传入不同泛型实参的泛型类在内存上只有一个，即还是原来的最基本的类型（本实例中GenericOfselfDemo），当然，在逻辑上我们可以理解成多个不同的泛型类型。
究其原因，在于Java中的泛型这一概念提出的目的，导致其只是作用于代码编译阶段，在编译过程中，对于正确检验泛型结果后，会将泛型的相关信息擦出，也就是说，成功编译过后的class文件中是不包含任何泛型信息的。泛型信息不会进入到运行时阶段。
对此总结成一句话：泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型。
本文中的例子主要是为了阐述泛型中的一些思想而简单举出的，并不一定有着实际的可用性。另外，一提到泛型，相信大家用到最多的就是在集合中，其实，在实际的编程过程中，自己可以使用泛型去简化开发，且能很好的保证代码质量。并且还要注意的一点是，Java中没有所谓的泛型数组一说。