Java泛型（generics）是JDK 5中引入的一个新特性，允许在定义类和接口的时候使用类型参数（type parameter）。声明的类型参数在使用时用具体的类型来替换。 这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。 Java语言引入泛型的好处是安全简单。
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。
规则和限制：
1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
3、泛型的类型参数可以有多个。
4、泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。
5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");
6、Java泛型无法向上转型
如：Info< String> i1 = new Info< String>() ; // 泛型类型为String
Info< Object> i2 = null ;
i2 = i1 ; //这句会出错 incompatible types
例子一：普通泛型
package heima;
class Gen<T> {//此处可以随便写标识符号，T是type的简称
private T var; //定义泛型成员变量,var的类型由T指定，即：由外部指定
public Gen(T var) {
this.var = var;
}
public T getvar() {
return var;
}
public void setvar(T var) {
this.var = var;
}
public void showType() {
System.out.println("T的类型是: " + var.getClass().getName());//通过反射获取输入对象的类型
}
}
public class GenDome1 {
public static void main(String[] args){
Gen<Integer> intvar=new Gen<Integer>(88);//定义泛型类Gen的一个Integer版本，并赋值，注意格式
intvar.showType();
int i= intvar.getvar();
System.out.println(i);
Gen<String> strvar=new Gen<String>("Hello Gen!");//定义泛型类Gen的一个String版本
strvar.showType();
String s=strvar.getvar();
System.out.println(s);
}
}
程序运行结果：
例子二：通配符泛型
package heima;
import java.util.Arrays;
class Gen2<T>{
private T var ; // 定义泛型变量
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
public String toString(){ // 直接打印
return this.var.toString() ;
}
};
public class GenTest2{
public static void main(String args[]){
Gen2< String> s = new Gen2< String>() ; // 使用String为泛型类型
s.setVar("it") ; // 设置内容
fun(s) ;
Gen2< Integer> i = new Gen2< Integer>( ) ; // 使用Integer为泛型类型
i.setVar(88) ; // 设置内容
fun(i) ;
Gen2< Arrays> a = new Gen2< Arrays>( ) ; // 使用Integer为泛型类型
}
public static void fun(Gen2< ?> temp){ // 可以接收任意的泛型对象 ,?表示任意类型
System.out.println("内容：" + temp) ;
}
};
程序运行结果：
例子三：受限泛型
package heima;
class Info< T>{
private T var ; // 定义泛型变量
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
public String toString(){ // 直接打印
return this.var.toString() ;
}
};
public class GenTest3{
public static void main(String args[]){
Info< Integer> i = new Info< Integer>() ; // 声明Integer的泛型对象
Info< Float> f = new Info< Float>() ; // 声明Float的泛型对象
i.setVar(30) ; // 设置整数，自动装箱
f.setVar(30.1f) ; // 设置小数，自动装箱
fun(i) ;
fun(f) ;
}
public static void fun(Info< ? extends Number> temp){ // 只能接收Number及其Number的子类 这里通过继承来限制子类的范围，还可以通过Super来实习
System.out.println(temp);
}
};
程序运行结果：
例子四：泛型接口
package heima;
interface Info5< T>{ // 在接口上定义泛型
public T getVar() ; // 定义抽象方法，抽象方法的返回值就是泛型类型
}
class InfoImpl< T> implements Info5<T>{ // 定义泛型接口的子类
private T var ; // 定义属性
public InfoImpl(T var){ // 通过构造方法设置属性内容
this.setVar(var) ;
}
public void setVar(T var){
this.var = var ;
}
public T getVar(){
return this.var ;
}
};
public class GenTest5{
public static void main(String arsg[]){
Info5 i =null; // 声明接口对象
i = new InfoImpl< String>("汤姆") ; // 通过子类实例化对象
System.out.println("内容：" + i.getVar()) ;
}
};
程序运行结果：
例子五：泛型数组
package heima;
public class GenTest5{
public static void main(String args[]){
Integer i[] = fun1(1,2,3,4,5,6) ; // 返回泛型数组 ，这里参数是手动传入的，可以保证是integer数组
fun2(i) ;
}
public static < T> T[] fun1(T...arg){ // 接收可变参数，不用确定参数类型
return arg ; // 返回泛型数组
}
public static < T> void fun2(T param[]){ // 输出
System.out.print("接收泛型数组：") ;
for(T t:param){
System.out.print(t + "、") ;
}
}
};
程序运行结果：
例子六：通过泛型方法返回泛型类型实例
package heima;
//通过泛型方法返回泛型类型实例
class Info< T extends Number>{ // 指定上限，只能是数字类型
private T var ; // 此类型由外部决定
public T getVar(){
return this.var ;
}
public void setVar(T var){
this.var = var ;
}
public String toString(){ // 覆写Object类中的toString()方法
return this.var.toString() ;
}
};
public class GenTest6{
public static void main(String args[]){
Info< Integer> i = fun(30) ;
System.out.println(i.getVar()) ;
}
public static < T extends Number> Info< T> fun(T param){//方法中传入或返回的泛型类型由调用方法时所设置的参数类型决定
Info< T> temp = new Info< T>() ; // 根据传入的数据类型实例化Info
temp.setVar(param) ; // 将传递的内容设置到Info对象的var属性之中
return temp ; // 返回实例化对象
}
};
程序运行结果：
