java 泛型

泛型是jdk1.5新出的一种应用，它可以使集合的实例关联或绑定到某种特定的类型。不用它，并不会引起什么问题，但尽量还是使用的好，这样能更加规范，更重要的是，

public String get(List list){
      for(String s:list){
             System.out.println(s)
      }
}

 

 如果你偶然往list加入了一个int类型的值，那么只有在运行时，我们才会发现它报出的classcast错误，但如果使用泛型

 

private List<String> list;

public String get(List<String> list){
      for(String s:list){
             System.out.println(s)
      }
}

 

 那么当加入int类型的值时，就会有一个编译错误，方便我们即时发现。

特定类型的泛型

 

private List<Object> linkedList = new LinkedList<Object>();
	public void add(String s){
		linkedList.add(s);
	}

 

 这样是可行的，因为String显然是Object，所以可以添加，但是

 

   public String addTest(List<Object> list){
                Object o = new Object();
                list.add(o);
		return null;
	}
	
	public void test(){
		List<String> listString = new LinkedList<String>();
		listString.add("a");
		getTest(listString);//not work
	}

 

 

 是不行的，因为getTest的参数list绑定到Object，会限制它只能保存Object类型的对象，而不能是Object的任何子类。如果可以的话，用户可以在addTest()方法中将一个Object对象加入到listString中，然后取的时候，会意外得到这个Object对象，这就违背了泛型的初衷，List<String>只能有String对象，不能有Object对象（Object对象不一定是String）。

上面的代码可行，是因为List<Object> linkedList只能是Object，而String对象显然也是Object。

使用通配符

 

       public String getTest(List<? extends Object> list，Object o){
		list.add(o);//这句将编译错误
		for(Object ob:list){
			System.out.println(ob);
		}
		return null;
	}

  当你不知道你要将list绑定为哪种类型时，使用通配符将很方便，所以Object的子类（其实就是所有类）都可以做为绑定类型，然后调用getTest()方法，然后遍历list。

但要注意，得到list的元素是很方便，但却不能任意添加。上面那个编译错误就说明了问题。因为List的绑定类型可能是String或者其它（只要不是Object就会出问题），则不能添加一个Object对象。所以，根据java的原则，如果不能判断某个给定的操作是否安全，那就全部禁止它。

范型方法

要解决上面的问题，就可以使用范型方法

 

	public <T>String getTest(List<T> list,T o){
		list.add(o);//这句将编译错误
		for(T ob:list){
			System.out.println(ob);
		}
		return null;
	}

  这样，将list绑定为T类型（其实也未知），添加的也是T类型，就不会有什么问题了。

 

 

当然，要使用特定范型，需要在方法前面加上<T>，如上面的public <T>String getTest(List<T>list,T o)，也可以将类范型化，如

 

public class RawT<T> {
	
	public String getTest(List<T> list,T o){
		list.add(o);//这句将编译错误
		for(T ob:list){
			System.out.println(ob);
		}
		return null;
	}
}

 

多类型参数泛化原理（擦拭法）

 

public class MultiHashMap<K,V>{
	private Map<K,List<V>> map = new HashMap<K,List<V>>();
	
	public void put(K key,V value){
		List<V> values = map.get(key);
		if(values == null){
			values = new LinkedList<V>();
			map.put(key, values);
		}
		values.add(value);
	}
	
	public List<V> get(K key){
		return map.get(key);
	}
}

 

 

当你要实例化为MultiHashMap<Date,String>时，Sun有不止一种，来实现对参数化类型的支持。一种可能的方法是为每种参数化类与类型的绑定，创建一个全新的类型定义。当绑定到一个类型时，源代码 中的裸类型变量的每次出现，都会被 替换为所绑定的类型。这种技术为C++使用，如果java使用这种方法，那么就出在幕后创建如下代码:

 

public class MultiHashMap<Date,String>{
	private Map<Date,List<String>> map = new HashMap<Date,List<String>>();
	
	public void put(Date key,String values){
		List<String> values = map.get(key);
		if(values == null){
			values = new LinkedList<String>();
			map.put(key,values);
		}
		values.add(value);
	}
	public List<String> get(Date key){
		return map.get(key);
	}
}

 

 如果实例化为MultiHashMap<String,String>，那么又将在幕后创建另一套代码。

Java使用一种不同的方法，叫做“擦拭法”。不同于创建一个独立 的类型定义，Java擦拭了参数化类型的信息，并创建一个单一的等效类型。每个类型参数与一个称为它的“上限”的约束相关联，缺省是java.lang.Object。客户端的绑定信息被擦去，并替换为适当的强制转型类型。MultiHashMap将会被翻译为

 

public class MultiHashMap{
	private Map map = new HashMap();
	//因为Date和String的父类为Object，所以使用上限Object
	//如果是调用MultiHashMap<K extends Number,V extends Integer>
	//此处会变为put(Number key,Integer value)
	public void put(Object key,Object value){
		List values = (List)map.get(key);//强制类型转换
		if(values == null){
			values = new LinkedList();
			map.put(key,values);
		}
		values.add(value);
	}
	public List get(Object key){
		return (List)map.get(key);//强制类型转换
	}
	
}

 

 

这样只需要创建一套后台代码即可。但出去擦拭法的原因，Java对参数化类型的使用有许多限制。

 

擦拭法的局限

由于擦拭法的原因，参数化类型的对象没有关于绑定类型的信息。所以在如下代码会出现编译错误。

 

K t = new K();

  拭意味着裸类型变量擦去了其上限，在MultiHashMap<K extends Number,V extends Integer>的例子中，即为Number。在大多数情况下，上限是一个抽象类，例如Number或Object（默认），因此创建这样类型的对象毫无用处。Java简单的禁止了这种操作。

在反射中的应用

反射包也被翻新了，来为参数化类型和方法提供参数信息。

Sun改动了Java的字节码规范。Class文件现在要保存关于类型参数的附加信息。最重要的是，Class类也被修改为一个参数化的类型，Class<T>。下面的赋值是有效的：

 

Class<String> klass = String.class;

 

  反射的修改，为你提供了有关参数化类型和方法声明的信息。你无法从反射中得到的有关绑定类型变量的信息。如果你将一个LinkedList绑定到String，因为擦拭法，该信息是不为LinkedList对象所知的。因此，反射没有办法将它提交给你。如果能用下面的代码，将会是一件很爽的事：

 

public class MultiHashMap<K,V>{
   ....
   public Class<V> getKeyType(){
       return V.class;//无法编译通过
   }
}

 但因为擦拭法，它无法工作。