泛型方法、泛型类、泛型接口

泛型的几种正确写法：

　　|--List<String> list = new ArrayList<String>();  ----推荐使用的写法

　　|--List<String> list = new ArrayList(); ---可以使用，但不推荐，是为了兼容老版本

　　|--List list = new ArrayList<String>(); ---可以使用，但不推荐，是为了兼容老版本

 泛型是什么意思在这就不多说了，而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一次，可能不够灵活；而泛型方法可以在调用的时候指明类型，更加灵活。

泛型方法代码演示：

/*代码演示*/
package com.cnblogs.test;
public class Generic {
    /**
     * 泛型方法
     * @param <T> 声明一个泛型T
     * @param c 用来创建泛型对象
     * @return
     * @throws InstantiationException
     * @throws IllegalAccessException
     */
public <T> T getObject(Class<T> c) throws InstantiationException, IllegalAccessException{
        //创建泛型对象
        T t = c.newInstance();
        return t;
    }
}

//---------------------------------------------------------------------

package com.cnblogs.test;

/**
 * 测试实体模型
 *
 */
public class User {
    private String uid;
    private String pwd;
    
    public String getUid() {
        return uid;
    }
    public void setUid(String uid) {
        this.uid = uid;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    
}
//------------------------------------------------------
package com.cnblogs.test;

/**
 * 泛型调用演示
 *
 */
public class GenericTest {
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException{
        
        Generic generic = new Generic();        
        //调用泛型方法
        Object obj = generic.getObject(Class.forName("com.cnblogs.test.User"));
        //判断obj的类型是否是指定的User类型
        System.out.println(obj instanceof User);
    }
}

 泛型类： 类上的泛型声明 

          修饰符 class 类名<泛型>{        

          }

 泛型类中若有static 的方法，则该方法中不能用类的泛型类型（参看代码）：

public class Demo6<T> {
    public static void main(String[] args) {
        System.out.println(getData2(100));
    }

    public T getData(T data) {
        return data;
    }

    //静态方法
    public static T getData2(T data) {
        return data;
    }

}

编译以上代码会出现编译错误：无法从静态上下文中引用非静态类。

 

注意：静态方法不可以使用类中定义的泛型

因为类中的泛型需要在对象初始化时指定具体的类型，而静态优先于对象存在。

那么类中的静态方法如果需要泛型就需要单独进行泛型声明，声明泛型一定要写在static后，返回值类型之前。

泛型类细节：

1、创建对象的时候要指定泛型的具体类型

2、创建对象时可以不指定泛型的具体类型(和创建集合对象一眼)。默认是Object，例如我们使用集合存储元素的时候没有使用泛型就是那么参数的类型就是Object

3、类上面声明的泛型只能应用于非静态成员函数，如果静态函数需要使用泛型，那么

需要在函数上独立声明。

4、如果建立对象后指定了泛型的具体类型，那么该对象操作方法时，这些方法只能操作一种数据类型。

5、所以既可以在类上的泛型声明，也可以在同时在该类的方法中声明泛型。