Java泛型

Why

JDK1.5增加泛型支持在很大程度上是为了让集合能记住其元素的数据类型。在没有泛型前，一旦把一个对象“丢进”java集合中，集合就会忘记对象的类型，把所有对象当成Object类型处理。当程序从集合中取出对象后，就需要进行强制类型转换，这种强制类型转换不仅使代码臃肿，而且容易引起ClassCastException异常。

增加了泛型支持后的集合的优点：

可以记住集合中元素的类型，并可以在编译时检查集合中元素的类型，如果试图向集合中添加不满足类型要求的对象，编译器就会提示错误;

可以让代码更加简洁，程序更加健壮；

除此之外，Java泛型还增强了枚举类、反射等方面的功能。

总结起来就是在编译时会检查类型安全，并且所有的强制转换都是自动和隐式的，以提高代码重用率。

import java.util.List;
import java.util.ArrayList;

public class Solution {
public static void main(String[] args) {
//创建一个只想保存字符串的List集合
List strList = new ArrayList();

strList.add("疯狂java讲义");
strList.add("疯狂Android讲义");
//“不小心”把一个Integer对象“丢进”了集合
strList.add(5);    //①

strList.forEach(str->System.out.println(((String)str).length()));  //②
}
}

What、When、Where

所谓泛型，就是允许在定义类、接口、方法时使用类型形参，这个类型形参将在声明变量、创建对象、调用方法时动态地指定。

泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。

Java引入泛型的好处是安全简单。

规则限制

泛型的类型参数只能是类类型（包括自定义类)，不能是简单类型；

同一种泛型可以对应多个版本（因为参数类型是不确定的），不同的版本的泛型类实例是不兼容的；

泛型的类型参数可以有多个；

泛型的参数类型可以使用extends语句，例如< T extends superclass>。习惯上称为“有界类型”；

泛型的参数类型还可以是通配符类型。例如Class< ? > classType = Class.forName(“java.lang.String”).

How

1、定义泛型接口、类

public class Apple<T> {
private T info;
public Apple(){}

public Apple(T info) {
this.info = info;
}
public void setInfo(T info) {
this.info = info;
}
public T getInfo() {
return this.info;
}

public static void main(String[] args) {
Apple<String> a1 = new Apple<>("苹果");
System.out.println(a1.getInfo());
Apple<Double> a2 = new Apple<>(5.67);
System.out.println(a2.getInfo());
}
}

注意：当创建泛型类声明自定义类，为该类定义构造函数时，构造函数名还是原来的类名，不要增加泛型声明。例如，为Apple< T>类定义构造函数，其构造函数名依然是Apple，而不是Apple< T>！调用该构造函数时却可以使用Apple< T>的形式，当然应该为T形参传入实际的类型参数。Java7提供了菱形语法，允许省略< >中的类型参数。

事实上，并不存在泛型类，例如，

import java.util.List;
import java.util.ArrayList;

public class Test {

public static void main(String[] args) {

List<String> l1 = new ArrayList<>();
List<Integer> l2 = new ArrayList<>();
System.out.println(l1.getClass()==l2.getClass());
}
}

结果为true，因为不管泛型的实际类型参数是什么，他们在运行时总有同样的类（class）处理，在内存中也只占用一块内存空间，因此在静态方法、静态初始化块或者静态变量声明和初始化中不允许使用类型形参。比如下面代码：

public class R<T> {
//下面代码错误，不能在静态变量声明中使用类型参数
static T info;
T age;
public void foo(T msg){}
//下面代码错误，不能在静态方法声明中使用类型参数
public static void bar(T msg){}
}

由于系统并不会真正生成泛型类，所以intanceof运算符后不能使用泛型类。例如，下面代码是错误的:

java.util.Collection<String> cs = new java.util.ArrayList<>();
//下面代码编译时引起错误
if(cs intanceof java.util.ArrayList<String>(){}

2、设定类型通配符的上限

//定义一个抽象类Shape
public abstract class Shape {
public abstract void draw(Canvas c);
}
//定义一个Shape的子类Circle
public class Circle extends Shape {
public void draw(Canvas c) {
System.out.println("在画布"+c+"上画一个圆");
}
}
//定义一个Shape的子类Rectangle
public class Rectangle extends Shape {
public void draw(Canvas c) {
System.out.println("在画布"+c+"上画一个矩形");
}
}
public class Canvas {
public void drawAll(List<? extends Shape> shapes) {
for(Shape s : shapes) {
s.draw(this);
}
}
}

List< ? extends Shape > 是受限制通配符的例子，此处的问号（？）代表一个未知的类型，但是此处的这个未知类型一定是Shape的子类型，因此可以把Shape称为这个通配符的上限。

3、定义泛型方法

泛型方法的语法格式如下：

修饰符 <T,S> 返回值类型 方法名（形参列表）{
//方法体
}