泛型反射

从网上搜集资料整理：
百度知道资料：
[color=red]http://baike.baidu.com/view/1436058.htm
http://blog.csdn.net/explorers/article/details/454837[/color]

代码讲解：http://www.java2000.net/p7927
http://book.csdn.net/bookfiles/413/10041314917.shtml
泛型：
[color=blue]泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。这种参数类型可以用在类、接口和方法的创建中，分别称为泛型类、泛型接口、泛型方法。
Java语言引入泛型的好处是安全简单。
在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。
泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。[/color]特点：
1.泛型声明是一次编译，永远使用，它会变成一个单独的class文件，就像一个普通
　的类或接口声明。
2.本质是参数化类型。
3.泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。
4.同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。
5.泛型的类型参数可以有多个。
6.泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。
7.泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName(java.lang.String);
8.在类中包含参数化方法，而这个方法所在的类可以是泛型类，也可以不是泛型类。也就是说，是否拥有泛型方法，与其所在的类是否是泛型没有关系。

泛型方法使得该方法能够独立于类而产生变化。以下是一个基本的指导原则：无论何时，只要你能做到，你就应该尽量使用泛型方法。也就是说，如果使用泛型方法可以取代将整个类泛型化，那么就应该只使用泛型方法，因为它可以使事情更清楚明白。另外，对于一个static的方法而言，无法访问泛型类的类型参数，所以，如果static方法需要使用泛型能力，就必须使其成为泛型方法。

9.

示例对比：
声明：
1.List myIntList = new LinkedList();//1
　　myIntList.add(new Integer(0));//2
　　[color=blue]Integer x = (Integer) myIntList.iterator().next();//3[/color]
强制类型转换（编译器只能保证迭代器返回的
　　是一个对象，要保证对Integer类型变量的赋值是类型安全的话，必须进行类型转换。
　　类型转换可能会导致运行时错误。
）
2.List<Integer> myIntList = new LinkedList<Integer>();//1
　　myIntList.add(new Integer(0));//2'
　　[color=blue]Integer x = myIntList.iterator().next();//3[/color]
（编译器知道了myIntList的存储类型，遍历时不需要强制转换。程序（特别是大型的程序）的可读性和健壮性得到了提高）

继承性：
List<String> ls = new ArrayList<String>();//1
List<Object> lo = ls;//2（编译出错 虽然String时Object的子类，但泛型参数化后，ls不是lo的子类，不能转化。泛型参数化后集合里的东西假想为不会改变的，我们的本能把这些东西看作是不变的。）

简单src:

package test;

import java.util.ArrayList;
import java.util.List;

public class TestFanXing<E> {
	List <E> list  = new ArrayList<E>();
	private E ob;
	public List<E> getList() {
		return list;
	}
	public void setList(List<E> list) {
		this.list = list;
	}
	public E getOb() {
		return ob;
	}
	public void setOb(E ob) {
		this.ob = ob;
	}


	public static void main(String[] args) {

		TestFanXing<String> t  = new TestFanXing<String>();
		t.list.add("aaa");
		t.ob="bbb";
		System.err.println(t.list.get(0)+t.ob);
	}
}

package test;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class TestFanxingT<T extends Collection,K> {
	//也可以用T:代表Object及其子类型，
	//但不能用?(通配符范围是Object及其子类型)实例化时可用
	private T x;
	private K k;
	public TestFanxingT(T x,K k) {
		this.x = x;
	}

	public T getX() {
		return x;
	}

	public void setX(T x) {
		this.x = x;
	}


	public K getK() {
		return k;
	}

	public void setK(K k) {
		this.k = k;
	}

	/*
	 * 将数组值装进List集合并返回List(泛型方法此时类不需要声明为泛型类)
	 */
	public <G> List<G> getList(G[] arr){
		List <G>list = new ArrayList<G>(); 
		for(G obj:arr){
			list.add(obj);
		}
		return list;

	} 	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		TestFanxingT <ArrayList,String> t1 = null;
		t1 = new TestFanxingT<ArrayList,String>(new ArrayList(),"k");

	//TestFanxingT <Collection,Integer> t21 = null;//声明为  Collection编译出错:转换出错,用t2,t3方式声明ok
		//t21 = new TestFanxingT<ArrayList,Integer>(new ArrayList(),new Integer(2));

		TestFanxingT <? extends Collection,Integer> t2 = null;//?
		t2 = new TestFanxingT<ArrayList,Integer>(new ArrayList(),new Integer(2));

		TestFanxingT <?,Float> t3 = null;
		t3 = new TestFanxingT<ArrayList,Float>(new ArrayList(),new Float(2));	
		 //call getList()
		TestFanxingT <?,Integer> t4 = null;
		t4 = new TestFanxingT<ArrayList,Integer>(new ArrayList(),new Integer(2));
		//int[] arr  = new int[]{1,2,3};//简单数组类型不可以，因为范型参数是Object类型
		Integer[] arr  = new Integer[]{1,2,3};
		List<Integer> list  = t4.getList(arr);
		for(Integer obj:list){
			System.out.println(obj);
		}
	}


}

反射：
参考资料：http://dev.csdn.net/article/49/49876.shtm
http://orangewhy.iteye.com/blog/56011
http://www.iteye.com/topic/137944