泛型
所谓泛型就是变量类型的参数化，简单来理解就是（在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型）。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。
从使用的角度来讲的话就是，为了提高安全性，使用泛型的基础之上程序编译期间没有问题的话，那么执行期间一定没有问题。总结性的来讲：
泛型技术是给编译器使用的技术，用于编译时期。确保了类型的安全
看下边这个例子：
List list = new ArrayList();
list.add("test");
list.add(12);
for(int i = 0;i<list.size();i++){
System.out.println((String)list.get(i));
}
毫无疑问，程序在运行的时候一定会出问题，因此基于此类问题（在编译期间就可以发现问题）开启了泛型的使用。
下面主要针对以下几点进行说明:
(1)泛型使用的场景
(2)泛型的菱形运算符使用
(3)泛型的类型擦除
(4)泛型的通配符
(5)泛型的上下边界
(6)泛型在实际应用中经典的例子
(7)泛型的优缺点
1、泛型的使用场景
泛型主要使用在 泛型类 泛型接口 以及 泛型方法
泛型类：简单理解就是泛型应用在类的定义中，比较常见的是Java中的集合的常用类，List Set Map
1.1 泛型类
//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Generic<T>{
//key这个成员变量的类型为T,T的类型由外部指定
private T key;
public Generic(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
this.key = key;
}
public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
return key;
}
}
在实际使用中，可以传递实际的参数进行使用，也可以不进行指定通过参数进行默认指定；
Generic gen1 = new Generic("1234");
Generic gen2 = new Generic(1234);
Generic gen3 = new Generic('C');
Generic gen4 = new Generic(12.4);
1.2 泛型接口：
泛型接口的使用基本和类的用法相同。
//定义一个泛型接口
public interface Generator<T> {
public T next();
}
/**
* 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中
* 即：class FruitGenerator<T> implements Generator<T>{
* 如果不声明泛型，如：class FruitGenerator implements Generator<T>，编译器会报错："Unknown class"
*/
class NumGenerator<T> implements Generator<T>{
@Override
public T next() {
return null;
}
}
泛型接口方法入参
/**
* 传入泛型实参时：
* 定义一个生产器实现这个接口,虽然我们只创建了一个泛型接口Generator<T>
* 但是我们可以为T传入无数个实参，形成无数种类型的Generator接口。
* 在实现类实现泛型接口时，如已将泛型类型传入实参类型，则所有使用泛型的地方都要替换成传入的实参类型
* 即：Generator<T>，public T next();中的的T都要替换成传入的String类型。
*/
public class FruitGenerator implements Generator<String> {
private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
@Override
public String next() {
Random rand = new Random();
return fruits[rand.nextInt(3)];
}
}
1.3 泛型方法
泛型类，是在实例化类的时候指明泛型的具体类型；
泛型方法，是在调用方法的时候指明泛型的具体类型 ;
/**
* 泛型方法的基本介绍
* @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{
T instance = tClass.newInstance();
return instance;
}
public static void main(String[] args){
Object obj = genericMethod(Class.forName("com.test.test"));
}
泛型方法的基本使用：
/**
* 这才是一个真正的泛型方法。
* 首先在public与返回值之间的<T>必不可少，这表明这是一个泛型方法，并且声明了一个泛型T
* 这个T可以出现在这个泛型方法的任意位置.
* 泛型的数量也可以为任意多个
* 如：public <T,K> K showKeyName(Generic<T> container){
* ...
* }
*/
public <T> T showKeyName(Generic<T> container){
System.out.println("container key :" + container.getKey());
//当然这个例子举的不太合适，只是为了说明泛型方法的特性。
T test = container.getKey();
return test;
}
普通方法非泛型方法
//这并不是一个泛型方法。
//这只是类中一个普通的成员方法，只不过他的返回值是在声明泛型类已经声明过的泛型。
//所以在这个方法中才可以继续使用 T 这个泛型。
public T getKey(){
return key;
}
静态方法与泛型
静态方法有一种情况需要注意一下，那就是在类中的静态方法使用泛型：
静态方法无法访问类上定义的泛型；
如果静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。
public class StaticGenerator<T> {
/**
* 如果在类中定义使用泛型的静态方法，需要添加额外的泛型声明（将这个方法定义成泛型方法）
* 即使静态方法要使用泛型类中已经声明过的泛型也不可以。
* 如：public static void show(T t){..},此时编译器会提示错误信息：
"StaticGenerator cannot be refrenced from static context"
*/
public static <T> void show(T t){
}
}
泛型使用场景总结：
（1）、无论何时，如果你能做到，你就该尽量使用泛型方法。也就是说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法。
（2）、另外对于一个static的方法而已，无法访问泛型类型的参数。
所以如果static方法要使用泛型能力，就必须使其成为泛型方法。
Java泛型中的常用字母的含义：
- T 代表一般的任何类。
- E 代表 Element 的意思，或者 Exception 异常的意思。
- K 代表 Key 的意思。
- V 代表Value 的意思，通常与 K 一起配合使用。
- S 代表 Subtype 的意思。
2、Java泛型菱形符号的使用：
这种写法是在JDK1.7版本之后才支持的，也被称为类型推断，简单举个例子来讲的话：
//为JDK版本1.5之后支持的写法
List<String> list = new ArrayList<String>();
//JDK1.7支持这样写
List<String> list = new ArrayList<>();
原因是编译器从List可以进行识别该泛型的入参。因此也被称为类型推断，后边不用写具体的泛型类型只需要写一对大括号就行。但是Java 7 只支持有限的类型推断：只有构造器的参数化类型在上下文中被显著的声明了，才可以使用类型推断，否则不行；
List<String> list = new ArrayList<>();
list.add("A");
//这样声明不合法
list.addAll(new ArrayList<>());
//这样声明合法
List<? extends String> list2 = new ArrayList<>();
list.addAll(list2);
3、泛型擦除
基础概念：运行时，会将泛型去掉，生成的class文件中是不带泛型的（泛型信息只存在于代码编译阶段，在进入 JVM 之前，与泛型相关的信息会被擦除掉，专业术语叫做类型擦除）首先读下下边的代码段：
List<String> test1 = new ArrayList<String>();
List<Integer> test2 = new ArrayList<Integer>();
System.out.println(test1.getClass() == test2.getClass());
输出为？true？Flase 原因？
答案为：true 原因正是由于Java的泛型类型擦除的原因，是因为 List和 List在 jvm 中的 Class 都是 List.class。那么有人指定会问和泛型的类型String和Integer没有任何关系吗？确实是没有在我看来
因为在泛型擦除的环节，之前泛型类中的类型参数部分如果没有指定上限，如 则会被转译成普通的 Object 类型，如果指定了上限如 则类型参数就被替换成类型上限。 举个例子说明下：
public class Bean<T>{
private T value;
public void setT(T value){
this.value = value;
}
public <T> T getT(){
return value;
}
public void add(T object){
}
}
Bean<String> init= new Bean<String>("hello");
Class test= init.getClass();
System.out.println("test class is:"+test.getName());
返回类型为:test class is:com.bean.test.Bean,返回结果并不是带有泛型类型的Bean,通过观察泛型T在JVM运行过程中的类型可以发现返回值为Object。
当我们把上边的Bean的实体类做一个小的改动<? extends String>,会发现在jvm验证类型过程中返回的是String类型。这也就验证了上面所说；
Field[] fs = test.getDeclaredFields();
for ( Field f:fs) {
System.out.println("Field name "+f.getName()+" type:"+f.getType().getName());
}
泛型类型擦除带来的限制：
但也因为类型擦除，它会抹掉很多继承相关的特性，这是它带来的局限性。当然在我们熟知这些特性之后，就可以避免很多雷区。看个例子：
public interface List<E> extends Collection<E>{
boolean add(E e);
}
上边为Java集合List 的源码声明方式；打个比方我现在想做的是：
List<Integer> init = new ArrayList<Integer>();
init.add(12);
init.add("test");
init.add(12.7);
直观角度看，应该是不行的。看下利用Java泛型擦除后的实现效果：
public class Test {
public static void main(String[] args) {
List<Integer> ls = new ArrayList<>();
ls.add(23);
try {
Method method = ls.getClass().getDeclaredMethod("add",Object.class);
method.invoke(ls,"test");
method.invoke(ls,42.9f);
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
for ( Object o: ls){
System.out.println(o);
}
}
}
令人意想不到的事情出现了：打印结果为
23
test
42.9
泛型通配符分为三种：
（1）、无限通配符<?>
（2）、上限通配符<? extends T>
（3）、下限通配符<? super T>
无限通配符<?>:
无线通配符的使用主要是为了应对Java中的继承关系。因为
class Father{}
class Son extends Father{}
Son son = new Son();
Father father= son;
如果应用到泛型之中的话这种体系就不存在了，List< Father> 不是List< Son>的父类，两者之间不存在任何关系。因此引入了无限通配符；
举个例子：
集合不能协变,但是数组可以进行协变。
协变的例子：
public static void method(ArrayList<?> list){
for(Object info:list){
System.out.println(info);
}
}
public static void method2(Person[] list){
for(Object info:list){
System.out.println(info);
}
}
//以下这两种写法没有问题，但是数据化后的不具有集成特性。产生协变
Person[] ps = new Person[2];
ps[1] = new Person();
ps[2] = new Person();
method2(ps);
Student[] student = new Student[2];
student[0] = new Student();
student[1] = new Student();
method2(ps);
上限通配符< ? extends T>
注意点：不能往里存，只能往外取
public class UpperBoundedWildcards {
public static double sum(List<? extends Number> numberlist) {
double sum = 0.0;
for (Number n : numberlist)
sum += n.doubleValue();
return sum;
}
public static void main(String args[]) {
List<Integer> integerList = Arrays.asList(10, 12, 23);
System.out.println("sum = " + sum(integerList));
List<Double> doubleList = Arrays.asList(11.2, 32.3, 53.7);
System.out.println("sum = " + sum(doubleList));
}
}
下限通配符<? Super T>
所谓下限通配符，就是指出了泛型使用的最低限制，只能使用其本身和超类；
使用规则与extends逻辑相同；适用于经常写入的情况；
总结：
1、extends 可用于返回类型限定，不能用于参数类型限定（换句话说：? extends xxx只能用于方法返回类型限定，jdk能够确定此类的最小继承边界为xxx，只要是这个类的父类都能接收，但是传入参数无法确定具体类型，只能接受null的传入）。
2、super 可用于参数类型限定，不能用于返回类型限定（换句话说：? supper xxx 只能用于方法传参，因为jdk能够确定传入为xxx的子类，返回只能用Object类接收）。
3、? 既不能用于方法参数传入，也不能用于方法返回。
6、泛型在实际编程中的例子：（后续代为补充）
7、泛型的优缺点分析：
（1）、避免了强制类型转换；
（2）、程序编译期间不出错，执行一定没有错误。提高了程序的安全性；
（3）、类型安全。增强了程序的可读性；
缺点以及局限性：由于泛型的擦除特性，会削弱很多继承的特性。
使用误区：
1、泛型中不能接受基本数据类型。这个应该很好理解因为<>中的大写字母通常代表的是Object ，所以要使用基本数据类型的话，也只能使用相关的包装类。
2、不能创建类型的泛型数组；
List<Integer>[] li2 = new ArrayList<Integer>[];
List<Boolean> li3 = new ArrayList<Boolean>[];
原因的话也很好理解，就是泛型的擦除，因为在编译期间不知道究竟是什么类型统一被转译为Object(或者是上限泛型类型)
不过借助泛型的无限通配符可以实现：
List<?>[] list= new ArrayList<?>[100];
list[1] = new ArrayList<String>();
List<?> v = list[1];
未完待续补充。。。如有新的见解欢迎下方留言。做技术我们是认真的Yep!haha
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
