Java中的泛型方法

　　泛型是什么意思在这就不多说了，而Java中泛型类的定义也比较简单，例如：public class Test<T>{}。这样就定义了一个泛型类Test，在实例化该类时，必须指明泛型T的具体类型，例如：Test<Object> t = new Test<Object>();，指明泛型T的类型为Object。

但是Java中的泛型方法就比较复杂了。

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

　　 定义泛型方法语法格式如下：

调用泛型方法语法格式如下：

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

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

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

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

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

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

再加上原作者的代码：

 1 /**
 2  * 泛型演示类
 3  * @author 杨元
 4  *
 5  */
 6 public class Generic {
 7     /**
 8      * 泛型方法
 9      * @param <T> 声明一个泛型T
10      * @param c 用来创建泛型对象
11      * @return
12      * @throws InstantiationException
13      * @throws IllegalAccessException
14      */
15     public <T> T getObject(Class<T> c) throws InstantiationException, IllegalAccessException{
16         //创建泛型对象
17         T t = c.newInstance();
18         return t;
19     }
20 }

 1 /**
 2  * 测试实体模型
 3  * @author 杨元
 4  *
 5  */
 6 public class User {
 7     private String uid;
 8     private String pwd;
 9     
10     public String getUid() {
11         return uid;
12     }
13     public void setUid(String uid) {
14         this.uid = uid;
15     }
16     public String getPwd() {
17         return pwd;
18     }
19     public void setPwd(String pwd) {
20         this.pwd = pwd;
21     }
22     
23 }

 1 /**
 2  * 泛型调用演示
 3  * @author 杨元
 4  *
 5  */
 6 public class GenericTest {
 7     public static void main(String[] args) 
　　　　　　throws InstantiationException, IllegalAccessException, ClassNotFoundException{
 8         
 9         Generic generic = new Generic();        
10         //调用泛型方法
11         Object obj = generic.getObject(Class.forName("User"));
12         //判断obj的类型是否是指定的User类型
13         System.out.println(obj instanceof User);
14     }
15 }

最后可再贴一些我的代码（代码是照着梁勇老师的Java语言程序设计原书第10版敲的）

 1 package generic;
 2 
 3 public class GenericMethodDemo {
 4     public static void main(String[] args) {
 5         Integer[] integers = {1, 2, 3, 4, 5};
 6         String[] strings = {"London", "Paris", "New York", "Austin"};
 7         
 8         GenericMethodDemo.<Integer>print(integers);
 9         GenericMethodDemo.<String>print(strings);
10         System.out.println();
11         //编译时会自动发现实际类型
12         print(integers);
13         print(strings);
14     }
15     
16     public static <E> void print(E[] list) {
17         for(int i = 0; i < list.length; i++) {
18             System.out.print(list[i] + " ");
19         }
20         System.out.println();
21     }
22 }

为了声明泛型方法，将泛型类型<E>置于方法头中关键字static之后：

public static <E> void print(E[] list)

其实就是返回类型之前，返回类型也可以是泛型的。

 1 package generic;
 2 
 3 import geometric.Circle;
 4 import geometric.Rectangle;
 5 import geometric.GeometricObject;
 6 
 7 public class BoundedTypeDemo {
 8     public static void main(String[] args) {
 9         Rectangle rectangle = new Rectangle(2, 2);
10         Circle circle = new Circle(2);
11         
12         System.out.println("Same area? " + 
13                 equalArea(rectangle, circle));
14     }
15     
16     public static <E extends GeometricObject> boolean equalArea(
17             E object1, E object2) {
18         return object1.getArea() == object2.getArea();
19     }
20 }

受限泛型类型<E extends GometricObject>

非受限泛型类型<E extends Object>

最后啰嗦一句：

定义一个泛型类 GenericStack<E>

定义一个泛型方法<E> void max(E e1, E e2)

消除泛型和对泛型的限制

限制 1：不能使用new E()

限制 2：不能使用new E[]

限制 3：在静态上下文中不允许类的参数是泛型类型

限制 4：异常类不能是泛型的