public class Generic {

/*

* 泛型类

* 泛型类和泛型接口的类型变量都是定义在类型级别的，其作用域可覆盖成员变量和成员方法。

* Test1<T>中，T是一个无限定的类型变量，类型擦除时用 Object 替换。

*/

class Test1<T> {

private T value;

public T getValue() {

return value;

}

public void setValue(T value) {

this.value = value;

}

}

/*

* 如果类型变量有限定，那么原始类型就用第一个边界的类型变量来替换。

* 以下类原始类型就是Comparable

*

* 如果 Test2 这样声明public class Test2<T extends Serializable&Comparable>

* 那么原始类型就用Serializable替换，而编译器在必要的时要向Comparable插入强制类型转换。

*

* 为了提高效率，应该将标签（tagging）接口（即没有方法的接口）放在边界限定列表的末尾。

*/

public class Test2<T extends Comparable & Serializable> {}

public static class Test3 {

// 泛型方法

public static <T> T add(T x,T y){

return y;

}

// 泛型方法的类型参数定义在方法签名中

// <T>表示这是一个泛型方法

// T是仅作用于 getObject方法 上的类型变量

public <T> T getObject(Class<T> clz) throws Exception {

T t = clz.newInstance();

return t;

}

}

// 泛型 接口

public interface Interface1<T1, T2> {

void doSomething(T1 t1, T2 t2);

}

public static class Test4<T2> implements Interface1<String, T2> {

// 如果实现一个泛型接口，可以在定义时直接传入具体的类型（如T1传入String），

// 也可以继续传入一个类型，待使用时再确认具体的类型。

@Override

public void doSomething(String s, T2 t2) {

System.out.println(s);

System.out.println(t2);

}

}

public static void main(String[] args) {

try {

ArrayList<String> arrayList1 = new ArrayList<String>();

arrayList1.add("abc");

ArrayList<Integer> arrayList2 = new ArrayList<Integer>();

arrayList2.add(123);

// 类型擦除

System.out.println(arrayList1.getClass());

System.out.println(arrayList2.getClass());

System.out.println(arrayList1.getClass() == arrayList2.getClass());

// 输出 :

// class java.util.ArrayList

// class java.util.ArrayList

// true

// 说明泛型类型String和Integer都被擦除掉了，只剩下了原始类型。

arrayList2.getClass().getMethod("add", Object.class).invoke(arrayList2, "asd");

// 利用反射 调用add方法的时候，却可以存储字符串。

// 这说明了Integer泛型实例在编译之后被擦除了，只保留了原始类型。

// 不指定泛型的时候

int i = Test3.add(1, 2); //两个参数都是Integer，所以T为Integer类型

Number f = Test3.add(1, 1.2); //两个参数是Integer 和 Float，所以取同一父类的最小级，为Number

Object o = Test3.add(1, "asd");//两个参数一个是Integer 和 String，所以取同一父类的最小级，为Object

// 指定泛型的时候

int a = Test3.<Integer>add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类

//int b = Test3.<Integer>add(1, 2.2); //编译错误，指定了Integer，不能为Float

Number c = Test3.<Number>add(1, 2.2); //指定为Number，所以可以为Integer和Float

new Test3().getObject(String.class);

Interface1<String, Integer> integerInterface1 = new Test4<>();

integerInterface1.doSomething("test", 123);

} catch (Exception e) {

System.out.println(e.getMessage());

}

}

}