泛型（Generic Type）是JDK1.5引入的影响最深远、对语言本身变革最大的Java新特性。
从Java 1.0版本发布以来，变化最大的部分就是泛型，致使JDK 1.5增加泛型机制的主要原因是为了满足在1999年制定的最早的Java规范需求（JSR 14）。

特点：
泛型可以将类型作为参数进行传递，即类型可以像参数一样实现参数化。
在编译的时候检查类型安全。
所有的强制转换都是自动和隐式的
Java引入泛型是安全简单的，并能提高代码的重用。
类型参数使用大写形式，且比较短。
在声明范型类的变量时可以使用通配符。

使用：
泛型类，是在实例化类的时候指明泛型的具体类型；
泛型方法，是在调用方法的时候指明泛型的具体类型。

限制：
[b]泛型和数组不同，它不具有协变性。[/b]
[b]使用<? extends ...>的定义的对象，不可以调用传递范型参数的方法[/b]

下面就开始举例介绍泛型类和泛型方法的简单使用
泛型类： 

public class A {

 private T t1;
 private T t2;

 public A(T t1, T t2) {
 this.t1 = t1;
 this.t2 = t2;
 }

 @Override
 public String toString() {
 return t1 +"  "+ t2;
 }

}



上述就是一个简单的泛型类，里面的变量的类型，是在new这个类的对象的时候外部传进来的，而且传入的两个构造参数的类型必须是你外部定义的类型。

例如： 

A<String> a = new A<String>("asd","123");


泛型方法声明： 

[img]http://dl2.iteye.com/upload/attachment/0094/8370/ba34aa99-7488-305f-a569-1644e05439b5.png[/img]



泛型方法调用： 

[img]http://dl2.iteye.com/upload/attachment/0094/8372/364ccfed-6517-39d9-9967-bb1c3cab0a7d.png[/img]


说明一下，定义泛型方法时，必须在返回值前边加一个，来声明这是一个泛型方法，持有一个泛型T，然后才可以用泛型T作为方法的返回值。

Class的作用就是指明泛型的具体类型，而Class类型的变量c，可以用来创建泛型类的对象。

为什么要用变量c来创建对象呢？既然是泛型方法，就代表着我们不知道具体的类型是什么，也不知道构造方法如何，因此没有办法去new一个对象，但可以利用变量c的newInstance方法去创建对象，也就是利用反射创建对象。

泛型方法要求的参数是Class类型，而Class.forName()方法的返回值也是Class，因此可以用Class.forName()作为参数。其中，forName()方法中的参数是何种类型，返回的Class就是何种类型。在本例中，forName()方法中传入的是User类的完整路径，因此返回的是Class类型的对象，因此调用泛型方法时，变量c的类型就是Class，因此泛型方法中的泛型T就被指明为User，因此变量obj的类型为User。

当然，泛型方法不是仅仅可以有一个参数Class，可以根据需要添加其他参数。

为什么要使用泛型方法呢？因为泛型类要在实例化的时候就指明类型，如果想换一种类型，不得不重新new一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。

为了能更说明问题，这里会多几个例子，慢慢体会泛型的用法。 

public class GenericAdd {

	// 泛型方法实现两个数相加
	public static  double add(T t1, T t2) {
		double sum = 0.0;
		sum = t1.doubleValue() + t2.doubleValue();
		return sum;
	}

	@SuppressWarnings("boxing")
	public static void main(String[] args) {

		int num1 = 3;
		int num2 = 4;
		System.out.println("整数和:" + GenericAdd.add(num1, num2));// 整数相加

		float num3 = 3.0f;
		float num4 = 7.0f;
		System.out.println("浮点数和:" + GenericAdd.add(num3, num4));// 浮点数相加

		double num5 = 99.0;
		double num6 = 1.0;
		System.out.println("双精度浮点数和:" + GenericAdd.add(num5, num6));// 双精度浮点数相加

		long num7 = 300;
		long num8 = 700;
		System.out.println("长整数和:" + GenericAdd.add(num7, num8));// 长整数相加
	}
}


开发一个方法，比较两个同类型对象 

public static > int pk(T o1, T o2) {
		if (o1 == null && o2 == null) {
			return 0;
		} else if (o1 == null) {
			return -1;
		} else if (o2 == null) {
			return 1;
		}
		return o1.compareTo(o2);
	}

下面主要介绍两种十分相似的java泛型方法的使用以及它们之间的区别。 

public class CommonService {

	private static HashMap<String,CommonService> map = new HashMap<String,CommonService>();

	//第一种
	public static <T extends CommonService> T getService1(Class<T> clazz)
	{
		T service = (T) map.get(clazz.getName());

		return service;
	}

        //第二种
	public static <T> T getService2(Class<? extends CommonService> clazz)
	{
		T service = (T) map.get(clazz.getName());

		return service;
	}
}

这两个泛型方法只有方法的签名不一样，方法体完全相同，那它们有什么不一样呢？

我们来使用一下它们，就知道它们的区别了。 

public class Main {

    public static void main(String[] args) {
        NoticeService noticeService1=CommonService.getService1(NoticeService.class);//正确的使用第一种泛型方法，不会出现编译错误。
        NoticeService noticeService2=CommonService.getService1(UserService.class);//不正确的使用第一种泛型方法，会出现编译错误。

        NoticeService noticeService3=CommonService.getService2(NoticeService.class);//正确的使用第二种泛型方法，不会出现编译错误，逻辑也正确，运行时不会出现异常。
        NoticeService noticeService4=CommonService.getService2(UserService.class);//不正确的使用第二种泛型方法，不会出现编译错误，但逻辑不正确，运行时会出现异常，危险！
    }
}

现在知道了这两种极其相似的泛型方法的区别了吧？

第一种泛型方法：返回值和参数值的类型是一致，推荐使用;

第二种泛型方法：返回值和参数值的类型不是一致，请谨慎或避免使用。

扩展：泛型的通配符

举例： 

List<? extends Number> list1=new ArrayList<Integer>();
        List<? extends Object> list2=new ArrayList<String>();
        //该语句也可写成如下形式：
        List<?> list3=new ArrayList<String>();

此时list1和list2以及list3均为只读的，不能进行add操作。也就是之前提到的不可以调用传递泛型参数的方法。