直接代码分析一波：
import java.util.*;
public class Ex12 {
public static void main(String[] args) {
Class c1 = new Double(0).getClass();
Class c2 = new Integer(0).getClass();
Class c3 = new ArrayList<String>().getClass();
Class c4 = new ArrayList<Integer>().getClass();
System.out.println(c1 == c2);
System.out.println(c3 == c4);
}
}这里的c1 c2 c3 c4将分别得到Double、Integer、ArrayList<String>、ArrayList<Integer>的类，输出是：
false
true
c1 == c2很明显是不一样的，这里的ArrayList<String>和ArrayList<Integer>很容易认为是不同的类型，但是其实他两是相同类型的，
import java.util.*;
class test1<T>{}
class test2<T,Q>{}
public class Ex12 {
public static void main(String[] args) {
test1<Double> t1 = new test1<Double>();
test2<Double, Double> t2 = new test2<Double, Double>();
System.out.println(Arrays.toString(t1.getClass().getTypeParameters()));
System.out.println(Arrays.toString(t2.getClass().getTypeParameters()));
}
}Class.getTypeParameters()将返回一个泛型声明所声明的类型参数数组，但是只能看到T，Q，得不到Double,这是因为在java泛型是使用擦除来实现的，这就意味这当你在使用泛型的时候，任何具体点的类型信息都被擦除了，唯一知道的就是你在使用一个对象，因此List<String>和List<Integer>是相同的类型。
1、边界
class HasF{
public void f() {System.out.println("f()");}
}
class Ma<T>{
T obj;
Ma(T t){ obj = t;}
public void maf(){obj.f();}//这里是错的
}假如你有一个HasF类，这个类中有一个f()方法，然后你想创建一个泛型类，并且想将obj的f()方法，这是java编译器无法实现的，因为擦除。为了调用f()，我们必须协助泛型类，给定泛型的边界，以此告知编译器只能接受遵循这个边界的类型。
用extends关键字，就能设置边界。
import java.util.*;
class HasF{
public void f() {System.out.println("f()");}
}
class Ma<T extends HasF >{
T obj;
Ma(T t){ obj = t;}
public void maf(){obj.f();}//这里是错的
}
public class Ex12 {
public static void main(String[] args) {
HasF hasf = new HasF();
Ma<HasF> ma = new Ma<HasF>(hasf);
ma.maf();
}
}边界<T extends HasF >声明T必须具有类型HasF或者从HasF导出的类型。
泛型类型参数将擦除到它的第一个边界，实际上编译器会把类型参数替换为它的擦除，上面的示例就是T擦除到HasF。
2、擦除的问题
泛型不能显式的引用运行时类型的操作中，例如转型、instanceof操作和new表达式，因为所有关于参数的类型信息都丢失了。例如：
class Foo<T>{
T var;
}
class Cat{}定义这样两个类，Foo是一个泛型类，Cat是一个普通类
Foo<Cat> foo = new Foo<Cat>();
这里看起来class Foo中的所有操作都像是使用Cat来操作，泛型好像也在告诉我们所有的类型T都将会被替换，但事实上我们必须提醒自己，被擦除了，它只是一个Object，也就是说这里没有边界，应该说边界就是Object。
import java.lang.reflect.Array;
import java.util.Arrays; class ArrayMaker<T>{
private Class<T> kind;
ArrayMaker(Class<T> kind){ this.kind = kind;}
T[] create(int size) {
return (T[])Array.newInstance(kind, size);//这里会有警告
}
} public class Ex13 {
public static void main(String[] args) throws Exception{
ArrayMaker<String> stringMaker =
new ArrayMaker<String>(String.class);
String[] stringArray = stringMaker.create(9);
System.out.println(Arrays.toString(stringArray));
}
}
输出：
[null, null, null, null, null, null, null, null, null]
即使这里的泛型被指定为Class<T>擦除就意味这kind实际被储存的是Class，由此在使用的时候，Array.newInstance(kind, size)并为拥有kind的类型信息，就是不知道kind是String.class，所以需要转型。
但是在创建一个容器情况稍有不同
public class Ex13<T> {
List<T> create(){return new ArrayList<T>();}
public static void main(String[] args) throws Exception{
Ex13<String> ex = new Ex13<String>();
List<String> stringList = ex.create();
}
}这里的编译器 不会给出任何的警告，尽管我们知道create中的<T>被移除了。这样就能这样操作：
public class Ex13<T> {
List<T> create(T t , int n){
List<T> result = new ArrayList<T> ();
for(int i = 0; i < n; i++)
result.add(t);
return result;
}
public static void main(String[] args) throws Exception{
Ex13<String> ex = new Ex13<String>();
List<String> stringList = ex.create("hello", 4);
System.out.println(stringList);
}
}输出：
[hello, hello, hello, hello]
但是数组就不能这样做：
public class Ex13<T> {
T[] create(T t , int n){
T[] result = new T[n];//这里编译器无法编译
for(int i = 0; i < n; i++)
result[i] = t;
return result;
}
public static void main(String[] args) throws Exception{
Ex13<String> ex = new Ex13<String>();
List<String> stringList = ex.create("hello", 4);
System.out.println(stringList);
}
}因为T的类型被擦除了。一般都使用Array.newInstance()方法或者使用List。
3、擦除的补偿
public class Ex13<T> {
public void f(Object o) {
if(o instanceof T) {}//编译出错
T var = new T();//编译出错
T[] ts = new T[10];//编译出错
T[] tss = (T)new Object[10];//编译出错
}
}因为擦除使泛型代码失去某些执行某些操作的能力，想要绕过这些问题进行编程需要引入类型标签对擦除进行补偿。
- instanceof的使用失败 可以使用动态的ISinstance）
public class Ex13<T> {
Class<T> kind;
Ex13(Class<T> kind){
this.kind = kind;
}
public boolean f(Object o) {
return kind.isInstance(o);
}
public static void main(String[] args) {
Ex13<String> ex = new Ex13<String>(String.class);
System.out.println(ex.f("233"));
System.out.println(ex.f(233));
}
}输出：
true
false
- T var = new T()；创建类型实例无法实现，一部分原因是因为擦除了，另一部分原因是因为编译器不能验证T具有默认（无参）的构造器，解决方法还是同样的使用Class对象。
public class Ex13<T> {
Class<T> kind;
Ex13(Class<T> kind){
this.kind = kind;
}
public T f() {
try {
return kind.newInstance();
} catch(Exception e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
String a = new Ex13<String>(String.class).f();
}
}调用用Class的newInstance()方法即可，但是如果在main中这样使用
public static void main(String[] args) {
Integer b = new Ex13<Integer>(Integer.class).f();
}就会失败，因为Integer是没有任何的默认的构造器。
可以使用显式的工厂，并限制其类型，使得只能接受实现这个类。
interface Factoryi<T>{
T create();
}先创建一个泛型接口，create()方法将返回一个T类对象。
可以
class IntegerFactory implements Factoryi<Integer>{
public Integer create() {
return new Integer(0);
}
}可以直接实现这个接口。
class Widest{
public static class Factory implements Factoryi<Widest>{
public Widest create() {
return new Widest();
}
}
}可以在这个类中创建一个内部类去实现这个接口，
class Foo2<T>{
private T x;
public <F extends Factoryi<T>> Foo2(F factory){
x = factory.create();
}
}这就是实际上的泛型类了，因为Integer和Widest都没有任何默认的构造器，所以就创建一个类实现Factoryi<T>接口，实现其中的create()方法然后在泛型类从使用这个Factoryi<T>作为边界，使用其中的create()方法，从而实现在泛型类从创建泛型类型实例。
- 泛型数组
不能创建泛型数组，一般的解决方案是使用Araayist：
public class Ex13<T> {
public List<T> array = new ArrayList<T>();
public void add(T item) {
array.add(item);
}
public T get(int index) {
return array.get(index);
}
}这样和数组其实也能实现和数组差不多的功能。
还能通过传入Class类型对象，然后使用Array.newInstance()方法创建一个数组
class ArrayMaker<T>{
private Class<T> kind;
ArrayMaker(Class<T> kind){ this.kind = kind;}
T[] create(int size) {
return (T[])Array.newInstance(kind, size);//这里会有警告
}
}
public class Ex13 {
public static void main(String[] args) {
String[] s = new ArrayMaker<String>(String.class).create(10);
}
}5、通配符
先看一个数组的特殊行为：
class Fruit{}
class Apple extends Fruit{}
class Orange extends Fruit{}
class Jon extends Apple{}
public class Ex14 {
public static void main(String[] args) {
Fruit[] fruit = new Apple[10];
fruit[0] = new Apple();
fruit[1] = new Jon();
try {
fruit[2] = new Fruit();
}catch(Exception e) {
System.out.println(e.toString());
}
try {
fruit[3] = new Orange();
}catch(Exception e) {
System.out.println(e.toString());
}
}
}这里的输出是：
java.lang.ArrayStoreException: Fruit
java.lang.ArrayStoreException: Orange
这里创建了一个Apple数组，并将其赋值给一个Fruit数组。你可以将一个Apple或者Apple的子类对象放入数组，并不会有警告，和错误。
但是当你想要放入一个Fruit或是Orange对象的时候，编译器不会有警告但是运行的时候却能捕获到java.lang.ArrayStoreException异常，编译器不会给出警告是因为数组有一个Fruit[]引用，但是运行的时候数组机制知道这是一个Apple[]数组，所以就会抛出异常 。
类似的当我们试图使用泛型容器来代替数组的时候：
public class Ex14 {
public static void main(String[] args) {
List<Fruit> flist = new ArrayList<Apple>();
}
}这时编译器会直接给出警告，讲道理Apple是Fruit的子类，这应该属于向上转型，然而实际上这里并不是根本不是向上转型这里是两个List，Apple可以算是Fruit类型的，但是Apple的List并不是Fruit的List，这时如果想要建立某种类型的向上转型关系，就需要使用通配符了。
public class Ex14 {
public static void main(String[] args) {
List<? extends Fruit> flist = new ArrayList<Apple>();
flist.add(new Orange());
flist.add(new Apple());
flist.add(new Jon());
}
}然后创建List就不会报错了，但是后面的调用add()方法还是会给出警告。
flist的类型现在是List<? extends Fruit>，可以将其读为“具有任何从Fruit继承的类型的列表”，但是并不就意味着这个List就可以持有任何类型的Fruit。通配符指定的是没有指定具体类型，其实就是只能接受不能修改。
public class Ex14 {
public static void main(String[] args) {
List<Apple> list = new ArrayList<Apple>();
list.add(new Apple());
list.add(new Jon());
List<? extends Fruit> flist = list;
}
}这样的使用就是没错的。