Java5泛型的用法，T.class的获取

1.先定义接口（这里写的比较简单就一个方法，具体可以再增加）

public interface BaseDao<T> {

       T get(String id);

 

}

2.定义抽象类实现接口

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

 

public abstract class HibernateBaseDao<T> implements BaseDao<T> {

       private Class<T> entityClass;

 

       /**

        * 这个通常也是hibernate的取得子类class的方法

        *

        * @author "yangk"

        * @date 2010-4-11 下午01:51:28

        */

       public HibernateBaseDao() {

              Type genType = getClass().getGenericSuperclass();

              Type[] params = ((ParameterizedType) genType).getActualTypeArguments();

              entityClass = (Class) params[0];

              // entityClass  = Class<T> entityClass = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];

       }

 

       @Override

       public T get(String id) {

              try {

                     return entityClass.newInstance();

              } catch (InstantiationException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              } catch (IllegalAccessException e) {

                     // TODO Auto-generated catch block

                     e.printStackTrace();

              }

              return null;

       }

}

子类的构造函数会调用父类的构造函数，所以当子类实例化的时候，父类的entityClass 已经得到了T.class。

3.定义一个entity

 

public class Entity {

 

       private String name;

 

       public String getName() {

              return name;

       }

 

       public void setName(String name) {

              this.name = name;

       }

}

4.定义entity的DAO

 

public class EntityDao extends HibernateBaseDao<Entity> {

 

       public void otherOperation() {

 

       }

 

}

可以在里面定义父类没有的，针对具体子类特殊的方法。

5.测试

 

import static org.junit.Assert.assertNotNull;

 

import org.junit.After;

import org.junit.AfterClass;

import org.junit.Before;

import org.junit.BeforeClass;

import org.junit.Test;

 

public class JunitTest {

       @BeforeClass

       public static void setUpClass() throws Exception {

       }

 

       @AfterClass

       public static void tearDownClass() throws Exception {

       }

 

       @Before

       public void setUp() {

       }

 

       @After

       public void tearDown() {

       }

 

       /**

        * Test of getEClass method, of class tmp.

        */

       @Test

       public void testNewClass() {

              EntityDao testDao = new EntityDao();

              Entity e = testDao.get(null);

              assertNotNull(e);

       }

 

}

运行，可以看到测试顺利通过。

注意：上面子类DAO的写法public class EntityDao extends HibernateBaseDao<Entity>

一定要在父类后面带上泛型，负责编译就会出错。

 附：这是泛型擦拭法使得Generic无法获取自己的Generic Type类型。实际上BadClass<String>()实例化以后Class里面就不包括T的信息了，对于Class而言T已经被擦拭为Object，而真正的T参数被转到使用T的方法（或者变量声明或者其它使用T的地方）里面（如果没有那就没有存根），所以无法反射到T的具体类别，也就无法得到T.class。而getGenericSuperclass()是Generic继承的特例，对于这种情况子类会保存父类的Generic参数类型，返回一个ParameterizedType，这时可以获取到父类的T.class了，这也正是子类确定应该继承什么T的方法。