可以看出，编译器并没有记录具体类型，因为泛型在编译过程中，已经被编译器替换掉了。

这就带来了一些问题，如下代码所示：

public class Erased<T> {

private static final int SIZE = 100;

public void f(Object arg) {

if(arg instanceof T) {} // Cannot perform instanceof check against type parameter T

T var = new T(); // Cannot create a generic array of T

T[] array = new T[SIZE]; //Cannot create a generic array of T

T[] array1 = (T[])new Object[SIZE]; //Type safety: Unchecked cast from Object[] to T[]

}

}

许多运行期才能知道确切类型的代码，都会编译不通过。

泛型修饰类：

如代码所示，定义一个泛型类，在创建实例时，会根据传入的具体类型创建对应的实例。

public class Generics<T> {

private T arg;

public String f(T arg) {

return arg.toString();

}

public static void main(String[] args) {

Generics<String> generics = new Generics<String>();

String s = generics.f("111");

System.out.println(s);

}

}

泛型修饰方法：

如代码所示，返回值前的<K> 不能省略，否则就编程了泛型类中的普通方法，而不省略，则是泛型方法。

泛型方法在方法调用时根据传入的参数类型确定类型。

//泛型类

public class Generics<T> {

private T arg;

//泛型类的普通方法

public String f(T arg) {

return arg.toString();

}

//泛型方法

private static <K> K genericsType(K t)

{

return t;

}

public static void main(String[] args) {

Generics<String> generics = new Generics<String>();

String s = generics.f("111");

System.out.println(s);

Generics.genericsType(new Integer(1));

}

}

通配符:

那么，还有剩下的问题，我想更方便的使用这个类，既要传入Integer，也要传入String，如何处理呢。

如下这样会报错：

public class Generics<T> {

private T arg;

private ArrayList<T> arraylist;

public String f(T arg) {

return arg.toString();

}

private static <K> K genericsType(K t)

{

return t;

}

public static void main(String[] args) {

Generics<String> generics = new Generics<String>();

String s = generics.f("111");

System.out.println(s);

Generics.genericsType(new Integer(1));

generics.arraylist=new ArrayList<String>();

//报错，因为已经匹配了String

generics.arraylist=new ArrayList<Integer>();//Type mismatch: cannot convert from ArrayList<Integer> to ArrayList<String>

}

}

而使用通配符?后，就可以做到：

public class Generics<T> {

private T arg;

//使用通配符?

private ArrayList<?> arraylist;

public String f(T arg) {

return arg.toString();

}

private static <K> K genericsType(K t)

{

return t;

}

public static void main(String[] args) {

Generics<String> generics = new Generics<String>();

String s = generics.f("111");

System.out.println(s);

Generics.genericsType(new Integer(1));

generics.arraylist=new ArrayList<String>();

generics.arraylist=new ArrayList<Integer>();

}

}

通配符的上下界：

这个概念也很好理解，当使用通配符时，<? extends Generics> 表示某种特定类型 ( Generics或者其子类 ) 的泛型，<? super Generics>示某种特定类型 ( Generics或者其超类 ) 的泛型。因为泛型的擦除是有上界的，如果直接使用?，那么有些不关联的类，只能使用到Object的方法，因为编译器只能确定该类是Object的子类。

而使用了<? extends Generics>之后，所有的Generics类的方法，这个泛型均能使用。<? extends Generics>这种形式在很多场景中被广泛使用。