Java中的泛型

1. Java中泛型的概念

       Java泛型是Java SE1.5 的新特性，泛型的本质是参数化类型；也就是说，所操作的数据类型被指定为一个参数，这种参数类型可以用在类、接口、方法的创建中，分别称之为：泛型类、泛型接口、泛型方法。

       所谓参数化类型，是将类型由原来具体的类型参数化；类似于方法中的变量参数，此时类型也定义成参数形式(可称之为类型形参)，在调用时传入具体的类型(类型实参)。即，在不创建新的类型的情况下，通过泛型指定的不同类型来控制形参具体限制的类型。

2. 泛型的特性

    泛型只在编译阶段有效。在编译过程中，正确检验泛型结果后，会将泛型的相关信息查出，并且在对象进入和离开方法的边界处添加类型检查和类型转换的方法。也就是说，泛型信息不会进入到运行阶段。在编译之后，程序会采取去泛型化的措施。

   对此，总结成一句话：泛型类型在逻辑上可以看成是多个不同的类型，实际上都是相同的基本类型。

3. 泛型的使用

    泛型有三种使用方式，即：泛型类、泛型接口、泛型方法。

    (1) 泛型类：泛型类型使用于类的定义中。通过泛型可以完成对一组类的操作，对外开放相同的接口。例如：List、Set、Map。

          泛型类的语法结构如下：

class 类名称<泛型标识>{
    private 泛型标识 prop;   // 成员变量类型
    ......
}

       以下为泛型的一个具体代码实例：

/**
 * 泛型标识T可以随便为任意标识，常见的标识有：T、K、E、V 等形参，用于表示泛型
 * 在实例化泛型类的时候，必须之地那个T的具体类型
 */
public class Genericity<T>{
    private T prop;    // prop这个成员变量的类型为T，T的类型由外部指定
    
    public T getProp(){           // 泛型方法getProp()的返回值类型为T，T的类型由外部指定
        return prop;
    }

    public Genericity(T prop){    // 泛型构造方法形参prop的类型也为T，T的类型同样是由外部指定的
        this.prop = prop;
    }
}

// 泛型的类型参数只能是类类型（包括自定义类），不能是简单类型
// 传入的实参类型需要与泛型的类型参数类型相同
Genericity<Integer> generInt = new Genericity<Integer>(1234);

// 传入的实参类型需要与泛型的类型参数类型相同
Genericity<String> genericityStr = new Genericity<String>("ABCD");

// 传入的实参类型需要与泛型的类型参数类型相同
User user = new User(1001, "Hellen", "Hh123", "123567902");
Genericity<User> generUser = new Genericity<User>(user);

System.out.println("====》" + generInt.getProp());
System.out.println("====》" + generInt.getProp());
System.out.println("用户名:"+generUser.getProp().getUsername()+"; 密码:"+generUser.getProp().getPassword());


/* 以上程序运行后，控制台输出内容如下 */
====》1234
====》ABCD
用户名:Hellen; 密码:Hh123

需要注意的是，定义的泛型类，并不一定要传入泛型类型实参。在使用泛型的时候，若传入泛型实参，则会根据传入的泛型实参类型作相应的限制，此时泛型才会起到本应起到的限制作用。若不传入泛型实参，在泛型中使用泛型的方法或者成员变量定义的类型可以为任意类型。但是，可能会涉及到强制类型转换问题，如下代码所示：

Genericity generInt = new Genericity(123.456);
Genericity generStr = new Genericity(true);
		
User user = new User(1001, "Hellen", "Hh123", "123567902");
Genericity generUser = new Genericity(user);
		
		
System.out.println(generInt.getProp());
System.out.println(generStr.getProp());
System.out.println("用户编号:"+((User) generUser.getProp()).getId()+"; 联系电话:"+((User) generUser.getProp()).getTelephone());


/* 以上程序运行后，控制台输出内容如下 */
====》123.456
====》true
用户编号:1001; 联系电话:123567902

另外，注意： 泛型的类型参数只能是类类型，不能是简单类型；

                      不能对确切的泛型类型使用 instanceof 操作。

(2) 泛型接口：泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的产生器中。

/**
 * 泛型接口的定义及使用
 *
 * @param <T>
 */
public interface Generator<T> {
	public T method();
}

不传入泛型实参，实现泛型接口：

/**
 * 未传入泛型实参时，与泛型类的定义相同，在声明类的时候，需将泛型的声明也一起加到类中。
 * 即：class GenertorImpl<T> implements Generator<T>
 * 如果不在类中声明泛型，编译将会报错。
 *
 * @param <T>
 */
public class GenertorImpl<T> implements Generator<T> {
	@Override
	public T method() {
		// TODO Auto-generated method stub
		return null;
	}
}

当实现泛型接口的类传入泛型实参时：

/**
 * 当传入泛型实参时，定义一个生产器实现这个接口，虽然只创建了一个泛型接口Generator<T>,但是
 * 可以为T传入多个实参，形成多种类型的Generator接口。
 * 
 * @param <T>
 */
public class GeneratorImpl implements Generator<String> {
	private String[] strArr = new String[] { "Hellen", "Rose", "Jack", "Tom" };

	@Override
	public String method() {
		// TODO Auto-generated method stub
		Random rand = new Random();
		return strArr[rand.nextInt(3)];
	}
}

(3) 泛型方法：在Java种，泛型类的定义非常简单，但是泛型方法就比较复杂了。尤其是见到的大多数泛型类种的成员方法也都是用了泛型，有的甚至泛型类中也包含着泛型方法。

泛型类，是在实例化类的时候指明泛型的具体类型；泛型方法，是在调用方法的时候指明泛型的具体类型。

/**
 * 泛型方法的基本介绍
 * @param tClass	传入的泛型实参
 * @return T		返回值为T类型
 * @throws InstantiationException
 * @throws IllegalAccessException
 * 
 * 说明：(1) public与返回值中间的<T>非常重要，可以理解为声明此方法为泛型方法；
 * 		(2) 只有声明了<T>的方法才是泛型方法，泛型类中使用了泛型的成员方法并不是泛型方法；
 * 		(3) <T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T；
 * 		(4) 与泛型类的定义一样，此处T可以随便写为任意标识，如常见标识: T、E、K、V 等形式的参数常用于表示泛型；
	 */
	public <T> T generatorMethod(Class<T> tClass) throws InstantiationException, IllegalAccessException{
		T instance = tClass.newInstance();
		return instance;
	}

1) 泛型方法的使用

public class GeneratorTestSimple {
	/**
	 * 定义泛型类
	 * @author 李龑
	 * @param <T>
	 */
	public class Generator<T>{
		private T prop;
		/*
		 * 需要注意的是，虽然没在方法中使用了泛型，但是这并不是一个泛型方法；
		 * 这只是类中一个普通的成员方法，只不过它的返回值是在声明泛型类已经声明过的泛型而已；
		 */
		public T getProp() {
			return prop;
		}
		
		/*
		 * 这个方法显然是有问题的，编译会报错:E cannot be resolved to a type;
		 * 因为在类的声明中并未声明泛型E，所在在使用E作为形参和返回值时，编译器会无法识别。
		 */
//		public E setProp(E prop) {
//			this.prop = prop;
//		}
		
		/*
		 * 泛型类的构造方法
		 */
		public Generator(T prop) {
			this.prop = prop;
		}
	}
	
/*===============================================================================================================*/
	/*
	 * 这才是个真整的泛型方法：
	 * 首先，在public 和 返回值之间的 <T>是必不可少的，这表明这是一个泛型方法，并且声明了一个泛型T；
	 * 这个T可以出现在这个泛型方法的任意位置；
	 * 泛型的数量也可以为任意多个；例如下面的showProperty()方法；
	 */
	public <T> T showPropName(Generator<T> gener){
		System.out.println("The Prop is:"+gener.getProp());
		T result = gener.getProp();	// 这里制作说明而已，并无代码真实含义
		return result;
	}
	
	/*
	 * 泛型方法
	 */
	public <T,K> K showProperty(Generator<T> gener){
		K result = (K) gener.getProp();	// 这里制作说明而已，并无代码真实含义
		return result;
	}
	
	/*
	 * 这并不是一个泛型方法，而只是一个普通方法，只是它使用了泛型类作为形参而已
	 */
	public void showPropValue(Generator<String> obj){
		System.out.println("Test Simple ......");
	}
	
	/*
	 * 这并不是一个泛型方法，而只是一个普通方法，只是它使用了泛型通配符“？”而已;
	 * 同时这也印证了泛型通配符所描述的：？是一种类型实参，可以看作是所有类的父类；
	 */
	public void sjpwPropValueTwo(Generator<?> obj){
		System.out.println("Test Simple ......");
	}
	
	/*
	 * 这个方法是有问题的，编译器会为我们提示错误信息："UnKnown class 'E' ";
	 * 虽然声明了<T>,也表明了这是一个可以处理泛型的类型的泛型方法;
	 * 但是只声明了泛型类型T，并未声明泛型类型E，因此编译器并不知道该如何处理E这个类型。
	 */
//	public <T> T showPropertyNames(Generator<E> gener){
//		T result = gener.getProp();
//		return result;
//	}
	
	/*
	 * 此方法编译报错，对于编译器来说T这个类型并未在程序中声明过，因此编译报错；
	 * 所以这也不是正确的泛型方法声明。
	 */
//	public void showProps(T genericObj){
//		
//	}
}

2) 类中的泛型方法

/**
 * 类中的泛型方法
 */
public class GeneratorPerson {
    static class Person{
		@Override
		public String toString() {
			return "Person";
		}
	}
	
   static class Student extends Person{
		@Override
		public String toString() {
			return "Student";
		}
	}
	
   static class Food{
		@Override
		public String toString() {
			return "Food";
		}
	}
	
   static class GeneratorTests<T>{
		public void showOne(T t){
			System.out.println(t.toString());
		}
		
		/*
		 * 在泛型类中声明了一个泛型方法，使用泛型E，这种泛型E可以为任意类型，可以类型与T相同，也可以不同；
		 * 由于泛型方法在声明的时候会声明泛型<E>，因此即使在泛型类中并未声明过泛型，编译器也能够正确的识别泛型方法中的泛型。
		 */
		public <E> void showTwo(E t){
			System.out.println(t.toString());
		}
		
		/*
		 * 在泛型类中声明了一个泛型方法，使用泛型T，注意这个T是一种全新的类型，可以与泛型类中声明的T不是同一种类型
		 */
		public <T> void showThree(T t){
			System.out.println(t.toString());
		}
	}
	
	public static void main(String[] args) {
		Student stud = new Student();
		Food fd = new Food();
		
		GeneratorTests<Student> generTestStud = new GeneratorTests<Student>();
		generTestStud.showOne(stud); 	//student是Person的子类，所以此操作是允许的
		
//		generTestStud.showOne(fd);		//编译报错，因为泛型类型实参指定的是Person，而这里传入的是Food类型
		
		//以下两种方式都是可以的
		generTestStud.showTwo(stud);	
		generTestStud.showTwo(fd);
		
		//这两种方式也都是正确的
		generTestStud.showThree(stud);
		generTestStud.showThree(fd);
	}
}

3) 泛型方法与可变参数

/* 在Genericity<T>类中添加如下方法 */
public <T> void printMsg( T ... args){
	for(T t : args){
		System.out.println("测试结果t="+t);
	}
}

/* 在测试类的测试方法中添加如下测试代码 */
String[] arg = new String[]{"names","pwds","words","speeks","what"};
generInt.printMsg(arg);


/* 运行可得到如下测试打印结果 */
测试结果t=names
测试结果t=pwds
测试结果t=words
测试结果t=speeks
测试结果t=what

4) 静态方法与泛型

静态方法有一种情况需要注意，那就是在类中的静态方法使用泛型：静态方法无法访问类上定义的泛型；若静态方法操作的引用数据类型不确定的时候，必须要将泛型定义在方法上。即，若静态方法要使用泛型的话，必须将静态方法也定义成泛型方法。

5) 泛型方法总结

 泛型方法能使方法独立于类而产生变化，以下是基本的原则：

     无论何时，如果能做到，就该尽量使用泛型方法；也就说，如果使用泛型方法将整个类泛型化，那么就应该使用泛型方法，另外对于一个 static 修饰的方法，无法访问泛型类型的参数。所以，如果 static 方法要使用泛型能力，就必须使其成为泛型方法。

(4) 泛型通配符

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

    在实际应用中，通常需要一个在逻辑上可以同时表示多种引用类型的泛型，这时就可以考虑使用泛型类型的通配符了：

public void showPropValue(Genericity<?> obj){
	System.out.println("Test Simple value"+obj.getProp());
}

   如上面代码所示，类型通配符一般是使用 ？代替具体的类型实参，要注意的是，这里的 " ? " 是类型实参，而不是类型形参。

泛型通配符可以解决，当具体类型不确定的时候，这个通配符就是 " ? "；当操作类型，不需要使用类型的具体功能时，只使用 Object 类中的功能，那么可以用 “ ? " 通配符来表示未知类型。

4. 泛型上下边界

   在使用泛型时，还可以为传入的泛型类型实参进行上下边界的限制。如：类型实参只准传入某种类型的父类或者某种类型的子类。为泛型添加上边界，即就是传入的的类型实参必须使指定类型的子类型：

public void showKeyValue1(Generic<? extends Number> obj){
    System.out.println("泛型测试","key value is " + obj.getKey());
}

Generic<String> generic1 = new Generic<String>("11111");
Generic<Integer> generic2 = new Generic<Integer>(2222);
Generic<Float> generic3 = new Generic<Float>(2.4f);
Generic<Double> generic4 = new Generic<Double>(2.56);

//这一行代码编译器会提示错误，因为String类型并不是Number类型的子类
//showKeyValue1(generic1);

showKeyValue1(generic2);
showKeyValue1(generic3);
showKeyValue1(generic4);

  若将代码作如下修改：

public class Genericity<T extends Number> {
	private T prop;

	public T getProp() {
		return prop;
	}

	public Genericity(T prop) { // 泛型构造方法形参prop的类型也为T，T的类型同样是由外部指定的
		this.prop = prop;
	}
}

那么，代码：Generic<String> generic1 = new Generic<String>("11111"); 将会出现编译异常而报错，因为String不是Number类型的子类。

另一个实例：

//在泛型方法中添加上下边界限制的时候，必须在权限声明与返回值之间的<T>上添加上下边界，即在泛型声明的时候添加
//public <T> T showKeyName(Generic<T extends Number> container)，编译器会报错："Unexpected bound"
public <T extends Number> T showKeyName(Generic<T> container){
    System.out.println("container key :" + container.getKey());
    T test = container.getKey();
    return test;
}

通过以上两个实例可看出，泛型的上下边界添加， 必须与泛型的声明在一起。

5. 泛型数组

Java中是不能创建一个确切的泛型类型的数组的。而使用通配符创建泛型是可以的，例如：

// List<String>[] ls = new ArrayList<String>[10];  // 不能创建确切的泛型类型数组

List<?>[] ls = new ArrayList<?>[10];               // 可以使用通配符创建泛型类型数组

下面是Sun公司文档中的一个例子：

List<String>[] lsa = new List<String>[10]; // Not really allowed.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Unsound, but passes run time store check    
String s = lsa[1].get(0); // Run-time error: ClassCastException.

这种情况下，由于JVM泛型的擦除机制，在运行时JVM是不知道泛型信息的，所以可以给oa[1] 赋上一个ArrayList而不会出现异常，但是在取出数据的时候却要做一次类型转换，所以就会出现ClassCastException，如果可以进行泛型数组的声明，上面的这种情况在编译期将不会出现任何警告或者错误，只有在运行时才会出错。

而对泛型数组的声明进行限制，对于这样的情况，可以在编译期提示代码有类型安全问题，比没有任何提示要强很多。

下面是采用通配符的方式是被允许的：数组的类型不可以是类型变量，除非是采用通配符的方式，因为对于通配符的方式，最后取出数据时是要做显示的类型转换的。

List<?>[] lsa = new List<?>[10]; // OK, array of unbounded wildcard type.    
Object o = lsa;    
Object[] oa = (Object[]) o;    
List<Integer> li = new ArrayList<Integer>();    
li.add(new Integer(3));    
oa[1] = li; // Correct.    
Integer i = (Integer) lsa[1].get(0); // OK