java 泛型以及通配符

泛型（目标是类型安全性，主要用于集合）：参数化类型：

import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	
	public class TestDemo {
		public static void main(String[] args) {
			testList();
			testGenList();
		}
		public static void testList(){
			List list = new ArrayList();
			list.add("麻省理功");
			list.add("扑林四吨");
			list.add("哈佛");
			
			for(Iterator iter = list.iterator();iter.hasNext();){
				String s = (String) iter.next();
				System.out.println(s);
			}
	
		}
		public static void testGenList(){
			List <String> list = new ArrayList<String>();
			list.add("清华");
			list.add("北大");
			list.add("南开");
			
			for(String s:list){
				System.out.println(s);
			}
		}
	}

泛型通配符：

import java.util.ArrayList;
	import java.util.List;
	
	public class TestDemo {
		public static void main(String[] args) {
			List<Number> list2 = new ArrayList<Number>();
			list2.add(new Integer(1)); // new Integer(1) 被类型转化为Number
			list2.add(new Long(655));
			list2.add(new Double(26.54));
			list2.add(25.5);
			
			prt1(list2);
			prt2(list2);
			
			List<Integer> list3 = new ArrayList<Integer>();
			list3.add(new Integer(1));
			list3.add(9); // 9被转化为integer类型
			//prt1(list3);
			prt2(list3);
	
		}
		private static void prt1(List<Number> list){ //方法的参数的泛型
			for(Number n:list){
				System.out.println(n);
			}
		}
		private static void prt2(List<? extends Number> list){ //传过来的类型是继承于Number的类型就可以
			for(Number n: list){
				System.out.println(n);
			}
		}
	}

例：

class Gen<T>{
		T ob;
		Gen(T o){
			ob = o;
		}
		T getOb(){
			return ob;
		}
		void showType(){
			System.out.println("type of T is "+ob.getClass().getName());
		}
	}
	
	public class TestDemo {
		
		public static void main(String[] args) {
			Gen<Integer> iOb;
			iOb = new Gen<Integer>(33);
			iOb.showType();
			int v = iOb.getOb();
			System.out.println("value: "+ v);
			System.out.println("===================");
			
			Gen<String> strOb = new Gen<String>("Generices Test");
			strOb.showType();
			String str = strOb.getOb();
			System.out.println("value: "+str);
		}
		
	}

如果我们想参数化方法的参数和返回值的类型，这就引出了泛型方法的声明，声明一个泛型方法的方式如下：// 注意是把参数和返回值的类型参数化

<T> T passThrough(T obj) {
    return obj;
}


这个方法限制传入的参数的类型与返回的参数类型将一致，可以看到，在方法签名前加上<T>即可。我们可以这样调用这个方法：

String s1 = "Hello";
String s2 = this.<String>passThrough(s1);


这样的调用是不是比较奇怪？幸好提供了类型推断，根据参数的类型来自动判断方法的类型（比如返回值类型），因此可以直接调用：

String s1 = "Hello";
String s2 = this.passThrough(s1);


    如果方法有两个类型变量，类型推断将怎么处理呢？比如：

<T> T passThrough(T obj1,T obj2) {
        return (T)(obj1.toString()+obj2.toString());
    }

然后我们传入两个参数，一个String，一个int，那么返回什么呢？

String s1="test";
String s3=this.passThrough(s1, 1);  //编译出错