java 泛型的使用

一.Java 泛型（generics）: JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

注意:Java泛型中的标记符含义： 

 E - Element (在集合中使用，因为集合中存放的是元素)

 T - Type（Java 类）

 K - Key（键）

 V - Value（值）

 N - Number（数值类型）

 ？ -  表示不确定的java类型

Object跟这些标记符代表的java类型有啥区别呢？  
Object是所有类的根类，任何类的对象都可以设置给该Object引用变量，使用的时候可能需要类型强制转换，

但是用使用了泛型T、E等这些标识符后，在实际用之前类型就已经确定了，不需要再进行类型强制转换。

二.泛型方法

写一个泛型方法，该方法在调用时可以接收不同类型的参数。根据传递给泛型方法的参数类型，编译器适当地处理每一个方法调用。
定义泛型方法的规则：
(2.1)所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的<E>）。
(2.2)每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
(2.3)类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
(2.4)泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像int,double,char的等）。

	/**
	 * 泛型方法
	 * E - Element (在集合中使用，因为集合中存放的是元素)
	 * @param arrs  类型形参
	 */
	public static <E> void showArray(E[] arrs) {
		for (E e : arrs) {
			System.out.print(e + "\t");
		}
		System.out.println();
	}

测试:

 // 创建不同类型数组： Integer, Double 和 Character
        Integer[] intArray = { 10, 20, 30, 40 };
        Double[] doubleArray = { 1.1, 2.2, 3.3};
        Character[] charArray = { 'A', 'E', 'L', 'G'};
        showArray(intArray);
        showArray(doubleArray);
        showArray(charArray);

三. 泛型类

泛型类的声明和非泛型类的声明类似，除了在类名后面添加了类型参数声明部分。

和泛型方法一样，泛型类的类型参数声明部分也包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。因为他们接受一个或多个参数，这些类被称为参数化的类或参数化的类型。

/**
 * 泛型类
 * 
 * @author Administrator
 *
 * @param <T>
 *            T - Type（Java 类）
 */
public class Student<T> {
	private T t;  //属性

	//封装
	public T getT() {
		return t;
	}

	public void setT(T t) {
		this.t = t;
	}

}

测试:

  //T ==>String
        Student<String> stu= new Student<String>();
        stu.setT("bear");
        System.out.println(stu.getT());
        //T==>Double
        Student<Double> stuD= new Student<Double>();
        stuD.setT(125.65);
        System.out.println(stuD.getT());

四.类型通配符

 1、类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类。

public static void main(String[] args){
		//传入不同的对象
		List<Integer> intList=new ArrayList<Integer>();
		List<Double> doubleList=new ArrayList<Double>();
		List<String> stringList=new ArrayList<String>();
		//添加
		intList.add(100);
		doubleList.add(125.56);
		stringList.add("bear");
		
		//调用方法
		show(intList);
		show(doubleList);
		show(stringList);
		
	}
	/**
	 * 通配符 ? : 具体类型实参
	 * @param list
	 */
	public static void show(List<?> list){
		System.out.println("get[0]=>"+list.get(0));
	}

显示效果

解析： 因为getDate()方法的参数是List类型的，所以intList,doubleList,stringList都可以作为这个方法的实参，这就是通配符的作用

2、类型通配符上限通过形如List来定义，如此定义就是通配符泛型值接受Number及其下层子类类型。

	public static void main(String[] args){
		//传入不同的对象
		List<Integer> intList=new ArrayList<Integer>();
		List<Double> doubleList=new ArrayList<Double>();
		List<String> stringList=new ArrayList<String>();

		//添加
		intList.add(100);
		doubleList.add(125.56);
		stringList.add("bear");
		
		//调用方法
		showData(intList);
		showData(doubleList);
		//发生异常：限定了参数泛型上限只能为Number
//		showData(stringList);
		
	}

	
	/**
	 * 类型通配符<? extends T>  表示该通配符所代表的类型是T类型的子类。 
	 * @param list
	 */
	public static void showData(List<? extends Number> list){
		System.out.println("get[0]=>"+list.get(0));
	}

显示效果：

解析： 在(//1)处会出现错误，因为getUperNumber()方法中的参数已经限定了参数泛型上限为Number，所以泛型为String是不在这个范围之内，所以会报错

3、类型通配符下限通过形如 List<? super Number>来定义，表示类型只能接受Number及其三层父类类型，如Objec类型的实例。

public static void main(String[] args) {

		// 传入不同的对象
		List<Integer> intList = new ArrayList<Integer>();
		List<Number> numList = new ArrayList<Number>();
		List<Object> objList = new ArrayList<Object>();
		List<String> stringList = new ArrayList<String>();

		// 添加
		intList.add(100);
		objList.add(new Date().getTime());
		numList.add(36.5);
		stringList.add("bear");
		// 调用方法
		// 发生异常：限定了参数泛型下限为Integer,Number,Object
		//showSuper2(stringList);
		showSuper2(intList);
		showSuper2(objList);
		showSuper2(numList);

	}

	/**
	 * 下限 类型通配符<? super T> 表示该通配符所代表的类型是T类型的父类.
	 * 
	 * @param list
	 */
	public static void showSuper2(List<? super Integer> list) {
		System.out.println("get[0]=>" + list.get(0));
	}
	

效果如下：

注意:

• <? extends T>表示该通配符所代表的类型是T类型的子类。
• <? super T>表示该通配符所代表的类型是T类型的父类。