###特性
泛型只在编译阶段有效
public class GenericTest1 {
public static void main(String[] args) {
ArrayList<String> strings = new ArrayList<>();
ArrayList<Double> doubles = new ArrayList<>();
System.out.println(strings.getClass().equals(doubles.getClass()));
}
}
输出：true
编译之后程序会采取去泛型化的措施。也就是说Java中的泛型，只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息擦出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行时阶段。
对此总结成一句话：泛型类型在逻辑上看以看成是多个不同的类型，实际上都是相同的基本类型。
###泛型的使用
泛型的使用，分为：泛型类，泛型方法，泛型接口
####泛型类
泛型类型用于类的定义中，被称为泛型类
语法：
class 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
private 泛型标识 /*（成员变量类型）*/ var;
.....
}
}
public class GenericTest2<T extends Number> {
T value;
public T getValue() {
return value;
}
}
###泛型接口
泛型接口与泛型类的定义及使用基本相同。
- 当实现泛型接口的类，未传入泛型实参时：与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
- 当实现泛型接口的类，传入泛型实参时：则所有使用泛型的地方都要替换成传入的实参类型
interface GenericInterfaceTest3<T> {
public T next();
}
/**
* 未传入泛型实参时
* @param <T>
*/
class GenericInterfaceClassTest3<T> implements GenericInterfaceTest3<T> {
@Override
public T next() {
return null;
}
}
/**
* 传入泛型实参时：
*/
public class GenericTest3 implements GenericInterfaceTest3<String> {
String[] array = new String[]{"A", "B", "C"};
int count = 0;
@Override
public String next() {
count ++;
return array[count % 3];
}
public static void main(String[] args) {
GenericTest3 genericTest3 = new GenericTest3();
for (int i =0 ; i< 5; i++) {
System.out.println(genericTest3.next());
}
}
}
####泛型方法
泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型 。
/**
* 泛型方法的基本介绍
* @param tClass 传入的泛型实参
* @return T 返回值为T类型
* 说明：
* 1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
* 2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
* 3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
* 4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
*/
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
IllegalAccessException{
}
example
public class GenericMethod<T> {
T value;
public GenericMethod(T value) {
this.value = value;
}
/**
* 虽然在方法中使用了泛型，但是这并不是一个泛型方法。
* 这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
* 所以在这个方法中才可以继续使用 T 这个泛型。
* @return
*/
public T getValue() {
return value;
}
public void showValue(T genericObj){
System.out.println(value + " / " + genericObj);
}
public <T> T getLastValue(List<T> list) {
return (list.get(list.size() -1));
}
public <T> T getRandomValue(List<GenericMethod<T>> list) {
final Random random = new Random();
final GenericMethod<T> tGenericMethod = list.get(random.nextInt(list.size()));
return tGenericMethod.value;
}
public static void main(String[] args) {
final GenericMethod<String> stringGenericMethod = new GenericMethod<String>("23");
stringGenericMethod.showValue("5");
final ArrayList<GenericMethod<String>> objects = new ArrayList<>();
objects.add(stringGenericMethod);
objects.add(new GenericMethod<>("2ggg3"));
System.out.println(stringGenericMethod.getLastValue(objects).getValue());
System.out.println(stringGenericMethod.getRandomValue(objects));
}
}
#####可变参数的泛型方法
public class GenericMethod2<T> {
public <T> void out(T ... args) {
for (T t : args) {
System.out.println(t);
}
}
public static void main(String[] args) {
new GenericMethod2<>().out("A", 1, 1999L,0.3);
}
}
静态方法与泛型
静态方法无法访问类上定义的泛型；如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。即：如果静态方法要使用泛型的话，必须将静态方法也定义成泛型方法 。
public class StaticGenericMethod<T> {
// error
// public static void out(T t) {
//
// }
public static <T> void out(T t) {
System.out.println(t);
}
public static void main(String[] args) {
StaticGenericMethod.out("a");
}
}
###？super T 和? extends T区别
<? extends T>和<? super T>是Java泛型中的“通配符（Wildcards）”和“边界（Bounds）”的概念。 - <? extends T>：是指 “上界通配符（Upper Bounds Wildcards）” - <? super T>：是指 “下界通配符（Lower Bounds Wildcards）” ``` class Food { } class Fruit extends Food { } class Apple extends Fruit { } class RedApple extends Apple { } public class GenericExtendsSuperTest { public void genericExtends() { final List<? extends Fruit> fruits = new ArrayList<>(); //error //fruits.add(new Apple()); //fruits.add(new Fruit()); //fruits.add(new Object()); fruits.add(null); final Fruit fruit = fruits.get(0); final Apple apple = (Apple)fruits.get(0); fruits.contains(new Fruit()); } public void genericSuper() { final List<? super Fruit> fruits = new ArrayList<>(); fruits.add(new Apple()); fruits.add(new Fruit()); fruits.add(null); //error //final Fruit fruit = fruits.get(0); //final Apple apple = (Apple)fruits.get(0); //fruits.contains(new Fruit()); } } ``` ####知乎 > 作者：袁太富 链接：https://www.zhihu.com/question/20400700/answer/102419313 > 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 > > List ：”存的时候只能选一个类型。“List <? extends Fruit> 意思：List中所有元素都是Fruit的子类(包含本身)， > List <? super Fruit> 意思：List中所有元素都是Fruit的父类(包含本身) > 1、List <? extends Fruit>假设：Fruit有子类A、B、C 那么 list.add(A);list.add(B);list.add(C);显然错误(不能存多个类)。虽然我们现在看的是ABC3个类就会问为什么会把不同类型的存进去，我这样存不就好了。list.add(A);list.add(A);其实这也是错误的，因为在运行之前他可不知道你到底add进去的东西是什么类型，是一样还是不一样，因实例化的时候是? 待定。为了避免类型不同的情况，所以会编译不通过。 > 2、List <? super Fruit> 假设：Fruit有子类A、B、C 那么 list.add(A);list.add(B);list.add(C); 这却是可以的，为什么呢：因为他是这么存的：list.add((Fruit)A);list.add((Fruit)B); 自动强转了。因为小转大是隐性的，大转小才是强转需要加类型。那这里为什么又不能存Fruit的父类呢？ 因为见假设1，它是？号，类型代表待定，不跑起来他也不知道你到底存的什么。所以我们能手动add()进去的数据都必须是绝对安全的(最低级父类:本身)才能通过。所以直接add父类也是不行的。 ####PECS原则 我们可以总结出一条规律，”Producer Extends, Consumer Super”： - “Producer Extends” – 如果你需要一个只读List，用它来produce T，那么使用? extends T。 - “Consumer Super” – 如果你需要一个只写List，用它来consume T，那么使用? super T。 - 如果需要同时读取以及写入，那么我们就不能使用通配符了。 **或者** extends 可用于的返回类型限定，不能用于参数类型限定。 super 可用于参数类型限定，不能用于返回类型限定。 >带有super超类型限定的通配符可以向泛型对易用写入，带有extends子类型限定的通配符可以向泛型对象读取。——《Core Java》 ###类型擦除 类型擦除就是说Java泛型只能用于在编译期间的静态类型检查，然后编译器生成的代码会擦除相应的类型信息，这样到了运行期间实际上JVM根本就知道泛型所代表的具体类型。这样做的目的是因为Java泛型是1.5之后才被引入的，为了保持向下的兼容性，所以只能做类型擦除来兼容以前的非泛型代码。 我们先来看一下下面这个简单的例子： ``` public class Node { private T data; private Node next; public Node(T data, Node next) { this.data = data; this.next = next; } public T getData() { return data; } // ... } ``` 编译器做完相应的类型检查之后，实际上到了运行期间上面这段代码实际上将转换成： ``` public class Node { private Object data; private Node next; public Node(Object data, Node next) { this.data = data; this.next = next; } public Object getData() { return data; } // ... } ``` 这意味着不管我们声明Node还是Node，到了运行期间，JVM统统视为Node。有没有什么办法可以解决这个问题呢？这就需要我们自己重新设置bounds了，将上面的代码修改成下面这样： ``` public class Node