[2014-08-29]JAVA笔记_泛型（Generics）

一、介绍

       · 泛型是 JDK1.5 之后加入的。 通过引入泛型可以获得编译时类型的安全和运行时更小地抛出 ClassCaseExceptions 的可能。

       · 可以声明一个集合将接受/返回的对象的类型 

package com.bob.generics;

public class GenericFoo<T>{		//接受任意类型的类型
	
	private T foo;		//定义一个任意类型的成员变量，具体类型与类接受的实际类型相同
	
	public void setFoo(T foo1){		//修改成员变量值
		this.foo = foo1;
	}
	
	public T getFoo(){		//获得成员变量值
		return foo;
	}

	public static void main(String[] args) {
		
		GenericFoo<Boolean> foo1 = new GenericFoo<Boolean>();	//给类传具体的类型信息
		GenericFoo<Integer> foo2 = new GenericFoo<Integer>();
		
		foo1.setFoo(new Boolean(false));	//只能接受foo1引用的类型，编译时即可发现类型是否相符
		foo2.setFoo(new Integer(10));
		
		Boolean bln = foo1.getFoo();
		Integer inr = foo2.getFoo();
		
//		Long lo = foo2.getFoo();		//Error：编译是就检查出了foo2接受的是Integer类型
//		foo1 = foo2;	//Error:类型不匹配
		Object obj = foo2.getFoo();
		
		System.out.println(bln + " " + inr);
		System.out.println(obj);
		
	}
}

·当没有指定泛型继承的类型或接口时，默认使用 T extends Object，所以默认情况下任何类型都可以作为参数传入。

总结：所谓泛型，就是变量类型的参数化。

//泛型的泛型
package com.bob.generics;

public class WrapperFoo<T> {
	
	private GenericFoo3<T> foo;
	
	public GenericFoo3<T> getFoo() {
		return foo;
	}

	public void setFoo(GenericFoo3<T> foo) {
		this.foo = foo;
	}

	public static void main(String[] args) {
		GenericFoo3<Integer> foo = new GenericFoo3<Integer>();
		foo.setFoo(new Integer(-10));
		
		WrapperFoo<Integer> wrapper = new WrapperFoo<Integer>();
		wrapper.setFoo(foo);
		
		GenericFoo3<Integer> g = wrapper.getFoo();
		System.out.println(g.getFoo());
	}

}


class GenericFoo3<T>{
	private T foo;

	public T getFoo() {
		return foo;
	}

	public void setFoo(T foo) {
		this.foo = foo;
	}
}

二、 限制泛型可用类型

         ·在定义泛型类别是，预设可以使用任何的类型来实例化泛型类型中的类型，但是如果想要限制使用泛型类别时，只能用某个特定类型或者是其子类型才能实例化该类型时，可以在定义类型是，使用extends 关键字指定这个类型必须是继承某个类，或者实现某个接口。

package com.bob.generics;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

public class ListGenericFoo<T extends List> {	// T 只能是实现list接口的某个类型的实例
//泛型的特殊语法，这里只能用extends
	private T[] fooArray;
	
	public T[] getFooArray() {
		return fooArray;
	}

	public void setFooArray(T[] fooArray) {
		this.fooArray = fooArray;
	}
	
	public static void main(String[] args) {
		ListGenericFoo<ArrayList> foo1 = new ListGenericFoo<ArrayList>();
		ListGenericFoo<LinkedList> foo2 = new ListGenericFoo<LinkedList>();
		
		ArrayList[] arrayList = new ArrayList[10];
		foo1.setFooArray(arrayList);
		
		LinkedList[] linkedList = new LinkedList[10];
		foo2.setFooArray(linkedList);
		
//		ListGenericFoo<HashMap> foo3 = new ListGenericFoo<HashMap>();
		
	}
	
}

三、 类型通配声明

          可以使用“？” 通配子元，并使用“extends” 关键字限定类型持有者的型态。

package com.bob.generics;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;

public class GenericTest<T>{

	private T foo;

	public T getFoo() {
		return foo;
	}

	public void setFoo(T foo) {
		this.foo = foo;
	}
	
	public static void main(String[] args) {
		
		GenericTest<? extends List> ge = null;		//List以下
		
		ge = new GenericTest<ArrayList>();
		ge = new GenericTest<LinkedList>();
		
//		ge = new GenericTest<HashMap>();
		
		GenericTest<? super List> ge2 = null;		//List以上
		
//		ge2 = new GenericTest<ArrayList>();
		
		ge2 = new GenericTest<Object>();
		
		GenericTest<String> ge3 = new GenericTest<String>();
		ge3.setFoo("hello world");
		
		GenericTest<? extends Object> ge4 = ge3;	//这里只知道ge4是Object类型或者其子类型，并不知道具体是什么类型
//		GenericTest<?> ge4 = ge3;		//省略写法
		
		System.out.println(ge4.getFoo());
		
		ge4.setFoo(null);		//可以移除
		
		System.out.println(ge4.getFoo());
		
//		ge4.setFoo("welcome");		//不能增加
		
	}
	
}

小结： 使用 <?>或是<? extends SomeClass> 的声明方式，意味着只能通过该名称来取得所参考实例的信息，或者是移除某些信息，但不能增加它的信息，因为只知道当中放置的是 SomeClass 的子类，但不确定是什么类的实例，编译器不让您加入信息，理由是，如果可以加入信息的话，那么您就得记得取回来的实例是什么类型，然后转换为原来的类型方可进行操作，这就失去了使用泛型的意义。

五、 泛型的 继承  与 实现

         泛型也可以继承泛型，被继承的泛型其中公共的方法也会被继承下来。泛型也可以实现泛型接口。