关于java中的泛型以及用面向对象的继承性来简化DAO的代码量

今天看到这段代码，加深了对java中的泛型编程的理解：

 

public class BaseDao<T>{

    

private Class<T> entityClass;

@Autowired

private HibernateTemplate hibernateTemplate;

/**

* 通过反射获取子类确定的泛型类

*/

public BaseDao() {

Type genType = getClass().getGenericSuperclass();

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

entityClass = (Class) params[0];

}

 

/**

* 根据ID加载PO实例

* 

* @param id

* @return 返回相应的持久化PO实例

*/

public T load(Serializable id) {

return (T) getHibernateTemplate().load(entityClass, id);

}

 

 

 

@Repository

public class UserDao extends BaseDao<User> {

 

    private final String GET_USER_BY_USERNAME = "from User u where u.userName = ?";

    private final String QUERY_USER_BY_USERNAME = "from User u where u.userName like ?";

 

    /**

     * 根据用户名查询User对象

     *

     * @param userName 用户名

     * @return 对应userName的User对象，如果不存在，返回null。

     */

    public User getUserByUserName(String userName) {

List<User> users = (List<User>) getHibernateTemplate().find(GET_USER_BY_USERNAME, userName);

if (users.size() == 0) {

   return null;

} else {

   return users.get(0);

}

    }

 

    /**

     * 根据用户名为模糊查询条件，查询出所有前缀匹配的User对象

     *

     * @param userName 用户名查询条件

     * @return 用户名前缀匹配的所有User对象

     */

    public List<User> queryUserByUserName(String userName) {

return (List<User>) getHibernateTemplate().find(QUERY_USER_BY_USERNAME, userName + "%");

    }

}

 

我想大家对于上面的代码有兴趣以及有觉悟的地方应该是在红色的地方

百度之，搜API，算是理解了，便于大家理解：代码如下：

 

介绍

在Java SE 1.5之前，没有泛型的情况的下，通过对类型Object的引用来实现参数的“任意化”，“任意化”带来的缺点是要做显式的强制类型转换，而这种转换是要求开发者对实际参数类型可以预知的情况下进行的。对于强制类型转换错误的情况，编译器可能不提示错误，在运行的时候才出现异常，这是一个安全隐患。

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率。

编辑

1、泛型的类型参数只能是类类型（包括自定义类），不能是简单类型。

2、同一种泛型可以对应多个版本（因为参数类型是不确定的），不同版本的泛型类实例是不兼容的。

3、泛型的类型参数可以有多个。

4、泛型的参数类型可以使用extends语句，例如<T extends superclass>。习惯上称为“有界类型”。

5、泛型的参数类型还可以是通配符类型。例如Class<?> classType = Class.forName("java.lang.String");

泛型还有接口、方法等等，内容很多，需要花费一番功夫才能理解掌握并熟练应用。在此给出我曾经了解泛型时候写出的两个例子（根据看的印象写的），实现同样的功能，一个使用了泛型，一个没有使用，通过对比，可以很快学会泛型的应用，学会这个基本上学会了泛型70%的内容。

例子一：使用了泛型

class Gen<T> {

private T ob; //定义泛型成员变量

public Gen(T ob) {

this.ob = ob;

}

public T getOb() {

return ob;

}

public void setOb(T ob) {

this.ob = ob;

}

public void showType() {

System.out.println("T的实际类型是: " + ob.getClass().getName());

}

}

public class GenDemo {

public static void main(String[] args){

//定义泛型类Gen的一个Integer版本

Gen<Integer> intOb=new Gen<Integer>(88);

intOb.showType();

int i= intOb.getOb();

System.out.println("value= " + i);

System.out.println("----------------------------------");

//定义泛型类Gen的一个String版本

Gen<String> strOb=new Gen<String>("Hello Gen!");

strOb.showType();

String s=strOb.getOb();

System.out.println("value= " + s);

}

}

例子二：没有使用泛型

class Gen2 {

private Object ob; //定义一个通用类型成员

public Gen2(Object ob) {

this.ob = ob;

}

public Object getOb() {

return ob;

}

public void setOb(Object ob) {

this.ob = ob;

}

public void showTyep() {

System.out.println("T的实际类型是: " + ob.getClass().getName());

}

}

public class GenDemo2 {

public static void main(String[] args) {

//定义类Gen2的一个Integer版本

Gen2 intOb = new Gen2(new Integer(88));

intOb.showTyep();

int i = (Integer) intOb.getOb();

System.out.println("value= " + i);

System.out.println("---------------------------------");

//定义类Gen2的一个String版本

Gen2 strOb = new Gen2("Hello Gen!");

strOb.showTyep();

String s = (String) strOb.getOb();

System.out.println("value= " + s);

}

}

运行结果：

两个例子运行Demo结果是相同的,控制台输出结果如下：

T的实际类型是:

java.lang.Integer

value= 88

----------------------------------

T的实际类型是: java.lang.String

value= Hello Gen!

Process finished with exit code 0

看明白这个，以后基本的泛型应用和代码阅读就不成问题了。

编辑本段深入泛型

原始代码

有两个类如下，要构造两个类的对象，并打印出各自的成员x。

public class StringFoo {

private String x;

public StringFoo(String x) {

this.x = x;

}

public String getX() {

return x;

}

public void setX(String x) {

this.x = x;

}

}

public class DoubleFoo {

private Double x;

public DoubleFoo(Double x) {

this.x = x;

}

public Double getX() {

return x;

}

public void setX(Double x) {

this.x = x;

}

}

以上的代码实在无聊，就不写如何实现了。

重构

因为上面的类中，成员和方法的逻辑都一样，就是类型不一样，因此考虑重构。Object是所有类的父类，因此可以考虑用Object做为成员类型，这样就可以实现通用了，实际上就是“Object泛型”，暂时这么称呼。

public class ObjectFoo {

private Object x;

public ObjectFoo(Object x) {

this.x = x;

}

public Object getX() {

return x;

}

public void setX(Object x) {

this.x = x;

}

}

写出Demo方法如下：

public class ObjectFooDemo {

public static void main(String args[]) {

ObjectFoo strFoo = new ObjectFoo(new StringFoo("Hello Generics!"));

ObjectFoo douFoo = new ObjectFoo(new DoubleFoo(Double("33")));

ObjectFoo objFoo = new ObjectFoo(new Object());

System.out.println("strFoo.getX="+(StringFoo)strFoo.getX());

System.out.println("douFoo.getX="+(DoubleFoo)douFoo.getX());

System.out.println("objFoo.getX="+objFoo.getX());

}

}

运行结果如下：

strFoo.getX=Hello Generics!

douFoo.getX=33.0

objFoo.getX=java.lang.Object@19821f

解说：在Java 5之前，为了让类有通用性，往往将参数类型、返回类型设置为Object类型，当获取这些返回类型来使用时候，必须将其“强制”转换为原有的类型或者接口，然后才可以调用对象上的方法。

泛型来实现

强制类型转换很麻烦，我还要事先知道各个Object具体类型是什么，才能做出正确转换。否则，要是转换的类型不对，比如将“Hello Generics!”字符串强制转换为Double,那么编译的时候不会报错，可是运行的时候就挂了。那有没有不强制转换的办法----有，改用 Java5泛型来实现。

public class GenericsFoo<T> {

private T x;

public GenericsFoo(T x) {

this.x = x;

}

public T getX() {

return x;

}

public void setX(T x) {

this.x = x;

}

}

public class GenericsFooDemo {

public static void main(String args[]){

GenericsFoo<String> strFoo=new GenericsFoo<String>("Hello Generics!");

GenericsFoo<Double> douFoo=new GenericsFoo<Double>(new Double("33"));

GenericsFoo<Object> objFoo=new GenericsFoo<Object>(new Object());

System.out.println("strFoo.getX="+strFoo.getX());

System.out.println("douFoo.getX="+douFoo.getX());

System.out.println("objFoo.getX="+objFoo.getX());

}

}

运行结果：

strFoo.getX=Hello Generics!

douFoo.getX=33.0

objFoo.getX=java.lang.Object@19821f

和使用“Object泛型”方式实现结果的完全一样，但是这个Demo简单多了，里面没有强制类型转换信息。

下面解释一下上面泛型类的语法：

使用<T>来声明一个类型持有者名称，然后就可以把T当作一个类型代表来声明成员、参数和返回值类型。

当然T仅仅是个名字，这个名字可以自行定义。

class GenericsFoo<T> 声明了一个泛型类，这个T没有任何限制，实际上相当于Object类型，实际上相当于 class GenericsFoo<T extends Object>。

与Object泛型类相比，使用泛型所定义的类在声明和构造实例的时候，可以使用“<实际类型>”来一并指定泛型类型持有者的真实类型。类如

GenericsFoo<Double> douFoo=new GenericsFoo<Double>(new Double("33"));

当然，也可以在构造对象的时候不使用尖括号指定泛型类型的真实类型，但是你在使用该对象的时候，就需要强制转换了。比如：GenericsFoo douFoo=new GenericsFoo(new Double("33"));

实际上，当构造对象时不指定类型信息的时候，默认会使用Object类型，这也是要强制转换的原因。

编辑本段高级应用

限制泛型

在上面的例子中，由于没有限制class GenericsFoo<T>类型持有者T的范围，实际上这里的限定类型相当于Object，这和“Object泛型”实质是一样的。限制比如我们要限制T为集合接口类型。只需要这么做：

class GenericsFoo<T extends Collection>，这样类中的泛型T只能是Collection接口的实现类，传入非Collection接口编译会出错。

注意：<T extends Collection>这里的限定使用关键字extends，后面可以是类也可以是接口。但这里的extends已经不是继承的含义了，应该理解为T类型是实现Collection接口的类型，或者T是继承了XX类的类型。

下面继续对上面的例子改进，我只要实现了集合接口的类型：

public class CollectionGenFoo<T extends Collection> {

private T x;

public CollectionGenFoo(T x) {

this.x = x;

}

public T getX() {

return x;

}

public void setX(T x) {

this.x = x;

}

}

实例化的时候可以这么写：

public class CollectionGenFooDemo {

public static void main(String args[]) {

CollectionGenFoo<ArrayList> listFoo = null;

listFoo = new CollectionGenFoo<ArrayList>(new ArrayList());

//出错了,不让这么干。

//原来作者写的这个地方有误，需要将listFoo改为listFoo1

// CollectionGenFoo<Collection> listFoo1 = null;

// listFoo1=new CollectionGenFoo<ArrayList>(new ArrayList());

System.out.println("实例化成功!");

}

}

当前看到的这个写法是可以编译通过，并运行成功。可是注释掉的两行加上就出错了，因为<T extends Collection>这么定义类型的时候，就限定了构造此类实例的时候T是确定的一个类型，这个类型实现了Collection接口，但是实现 Collection接口的类很多很多，如果针对每一种都要写出具体的子类类型，那也太麻烦了，我干脆还不如用Object通用一下。别急，泛型针对这种情况还有更好的解决方案，那就是“通配符泛型”。

通配符泛型

为了解决类型被限制死了不能动态根据实例来确定的缺点，引入了“通配符泛型”，针对上面的例子，使用通配泛型格式为<? extends Collection>，“？”代表未知类型，这个类型是实现Collection接口。那么上面实现的方式可以写为：

public class CollectionGenFooDemo {

public static void main(String args[]) {

CollectionGenFoo<ArrayList> listFoo = null;

listFoo = new CollectionGenFoo<ArrayList>(new ArrayList());

//现在不会出错了

//原来作者写的这个地方有误，需要将listFoo改为listFoo1

CollectionGenFoo<? extends Collection> listFoo1 = null;

listFoo1=new CollectionGenFoo<ArrayList>(new ArrayList());

System.out.println("实例化成功!");

}

}

注意：

1、如果只指定了<?>，而没有extends，则默认是允许Object及其下的任何Java类了。也就是任意类。

2、通配符泛型不单可以向下限制，如<? extends Collection>，还可以向上限制，如<? super Double>，表示类型只能接受Double及其上层父类类型，如Number、Object类型的实例。

3、泛型类定义可以有多个泛型参数，中间用逗号隔开，还可以定义泛型接口，泛型方法。这些都与泛型类中泛型的使用规则类似。

编辑本段泛型方法

是否拥有泛型方法，与其所在的类是否泛型没有关系。要定义泛型方法，只需将泛型参数列表置于返回值前。如:

public class ExampleA {

public <T> void f(T x) {

System.out.println(x.getClass().getName());

}

public static void main(String[] args) {

ExampleA ea = new ExampleA();

ea.f(" ");

ea.f(10);

ea.f('a');

ea.f(ea);

}

}

输出结果：

java.lang.String

java.lang.Integer

java.lang.Character

ExampleA

使用泛型方法时，不必指明参数类型，编译器会自己找出具体的类型。泛型方法除了定义不同，调用就像普通方法一样。

需要注意，一个static方法，无法访问泛型类的类型参数，所以，若要static方法需要使用泛型能力，必须使其成为泛型方法。

 

 

 

 

深入：

 

 

泛型的好处：

    泛型的主要好处就是让编译器保留参数的类型信息，执行类型检查，执行类型转换（casting）操作，编译器保证了这些类型转换（casting）的绝对无误。

        /******* 不使用泛型类型 *******/
        List list1 = new ArrayList();
        list1.add(8080);                                  //编译器不检查值
        String str1 = (String)list1.get(0); //需手动强制转换,如转换类型与原数据类型不一致将抛出ClassCastException异常
       
        /******* 使用泛型类型 *******/
        List<String> list2 = new ArrayList<String>();
        list2.add("value");                 //[类型安全的写入数据] 编译器检查该值,该值必须是String类型才能通过编译
        String str2 = list2.get(0); //[类型安全的读取数据] 不需要手动转换
       

泛型的类型擦除：

    Java 中的泛型只存在于编译期，在将 Java 源文件编译完成 Java 字节代码中是不包含泛型中的类型信息的。使用泛型的时候加上的类型参数，会被编译器在编译的时候去掉。

    这个过程就称为类型擦除（type erasure）。

        List<String>    list1 = new ArrayList<String>();
        List<Integer> list2 = new ArrayList<Integer>();
       
        System.out.println(list1.getClass() == list2.getClass()); // 输出结果： true
        System.out.println(list1.getClass().getName()); // 输出结果： java.util.ArrayList
        System.out.println(list2.getClass().getName()); // 输出结果： java.util.ArrayList
       

在以上代码中定义的 List<String> 和 List<Integer> 等类型，在编译之后都会变成 List，而由泛型附加的类型信息对 JVM 来说是不可见的，所以第一条打印语句输出 true，

第二、第三条打印语句都输出 java.util.ArrayList，这都说明 List<String> 和 List<Integer> 的对象使用的都是同一份字节码，运行期间并不存在泛型。

来看一个简单的例子：

package test;

import java.util.List;
/**
 * -----------------------------------------
 * @描述  类型擦除
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-25 <p>
 * -----------------------------------------
 */
public class GenericsApp {

   
    public void method(List<String> list){
       
    }
   
    /*
     * 编译出错,这两个方法不属于重载,由于类型的擦除,使得这两个方法的参数列表的参数均为List类型,
     * 这就相当于同一个方法被声明了两次,编译自然无法通过了
     *
    public void method(List<Integer> list){
       
    }
    */
   
}

以此类为例，在 cmd 中 编译 GenericsApp.java 得到字节码（泛型已经擦除），然后再反编译这份字节码来看下源码中泛型是不是真的被擦除了：

 

从图中可以看出，经反编译后的源码中 method 方法的参数变成了 List 类型，说明泛型的类型是真的被擦除了，字节码文件中不存在泛型，也就是说，运行期间泛型并不存在，它在

编译完成之后就已经被擦除了。

泛型类型的子类型：

    泛型类型跟其是否是泛型类型的子类型没有任何关系。

        List<Object> list1;
        List<String> list2;
       
        list1 = list2; // 编译出错
        list2 = list1; // 编译出错

大家都知道，在 Java 中，Object 类是所有类的超类，自然而然的 Object 类是 String 类的超类，按理，将一个 String 类型的对象赋值给一个 Object 类型的对象是可行的，

但是泛型中并不存在这样的逻辑，用更通俗的话说，泛型类型跟其是否子类型没有任何关系。

泛型中的通配符（?）：

    由于泛型类型与其子类型存在不相关性，那么在不能确定泛型类型的时候，可以使用通配符（?），通配符（?）能匹配任意类型。

        List<?> list;
        List<Object> list1 = null;
        List<String>  list2 = null;
       
        list = list1;
        list = list2;

限定通配符的上界：

        ArrayList<? extends Number> collection = null;
       
        collection = new ArrayList<Number>();
        collection = new ArrayList<Short>();
        collection = new ArrayList<Integer>();
        collection = new ArrayList<Long>();
        collection = new ArrayList<Float>();
        collection = new ArrayList<Double>();
       

 ? extends XX，XX 类是用来限定通配符的上界，XX 类是能匹配的最顶层的类，它只能匹配 XX 类以及 XX 类的子类。在以上代码中，Number 类的实现类有：

AtomicInteger、AtomicLong、 BigDecimal、 BigInteger、 Byte、 Double、 Float、 Integer、 Long、 Short ，因此以上代码均无错误。

限定通配符的下界：

        ArrayList<? super Integer> collection = null;
       
        collection = new ArrayList<Object>();
        collection = new ArrayList<Number>();
        collection = new ArrayList<Integer>();
       

 ? super XX，XX 类是用来限定通配符的下界，XX 类是能匹配的最底层的类，它只能匹配 XX 类以及 XX 类的超类，在以上代码中，Integer 类的超类有：

Number、Object，因此以上代码均能通过编译无误。

通过反射获得泛型的实际类型参数：

    这个就有点难度了，上面已经说到，泛型的类型参数会在编译完成以后被擦除，那在运行期间还怎么来获得泛型的实际类型参数呢？这个是有点难度了吧？似乎不可能实现的样子，

    其实不然，java.lang.Class 类从 Java 1.5 起（如果没记错的话），提供了一个 getGenericSuperclass() 方法来获取直接超类的泛型类型，这就使得获取泛型的实际类型参数成为

    了可能，下面来看一段代码，这段代码很精辟，很有用，大家一定要学到手哈：

package test;

import java.lang.reflect.ParameterizedType;
/**
 * -----------------------------------------
 * @描述  泛型的实际类型参数
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-25 <p>
 * -----------------------------------------
 */
public class Base<T> {

    private Class<T> entityClass;
   
    //代码块,也可将其放置到构造子中
    {
        entityClass =(Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
           
    }
   
    //泛型的实际类型参数的类全名
    public String getEntityName(){
       
        return entityClass.getName();
    }
   
    //泛型的实际类型参数的类名
    public String getEntitySimpleName(){
       
        return entityClass.getSimpleName();
    }

    //泛型的实际类型参数的Class
    public Class<T> getEntityClass() {
        return entityClass;
    }
   
}

以上代码的精华全在这句：(Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];

实际上，这句话咋看起来很难看的明白，理解起来就更加的吃力了，下面容我来将这句复杂的代码拆分开来，理解起来可能会好些：

    //代码块,也可将其放置到构造子中
    {
        //entityClass =(Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        try {
            Class<?> clazz = getClass(); //获取实际运行的类的 Class
            Type type = clazz.getGenericSuperclass(); //获取实际运行的类的直接超类的泛型类型
            if(type instanceof ParameterizedType){ //如果该泛型类型是参数化类型
                Type[] parameterizedType = ((ParameterizedType)type).getActualTypeArguments();//获取泛型类型的实际类型参数集
                entityClass = (Class<T>) parameterizedType[0]; //取出第一个(下标为0)参数的值
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
           
    }
   

注意，获取 Class 实例的时候是用 getClass()，而不是用 Base.class，获取 Class 的方式有三种，这是其中的两种，还有一种是 Class.forName("类全名")，如需了解反射的基础知识

请前往上一篇随笔 java 反射基础

那么，Base.class 与 getClass()，这两个方法来获取类的字节码的时候，有什么不一样的地方呢？当然有不一样的地方了，Base.class 是写死了的，它得到的永远是 Base 类的字节码，

而 getClass() 方法则不同，在上面代码注释中的第一、二行注释我用了“实际运行的类”6个字，这几个字很重要，一定要理解，如果无法理解，下面的你可能就看不懂了。

为了方便大家的理解，下面插加一个小例子来加以说明 类.class 与 getClass() 两种方法来获取类的字节码有什么区别：

package test;
/**
 * -----------------------------------------
 * @描述  超类
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-25 <p>
 * -----------------------------------------
 */
public class Father {

    public Father (){
       
        System.out.println("Father 类的构造子：");
        System.out.println("Father.class ：" + Father.class);
        System.out.println("getClass()      ：" + getClass());
    }
   
}

package test;

/**
 * -----------------------------------------
 * @描述  超类的子类（超类的实现类）
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-25 <p>
 * -----------------------------------------
 */
public class Children extends Father{

   
}

package test;
/**
 * -----------------------------------------
 * @描述  测试类
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-25 <p>
 * -----------------------------------------
 */
public class Test {

    public static void main(String[] args){
       
        new Children(); //实际运行的类是Children（Father类的子类或者说是实现类）
    }
   
}

后台打印输出的结果：

Father 类的构造子：
Father.class ：class test.Father
getClass()      ：class test.Children

 从打印出的结果看来，类.class 与 getClass() 的区别很明了了，getClass() 获取的是实际运行的类的字节码，它不一定是当前类的 Class，有可能是当前类的子类的 Class，具体是哪

个类的 Class，需要根据实际运行的类来确定，new 哪个类，getClass() 获取的就是哪个类的 Class，而 类.class 获取得到的 Class 永远只能是该类的 Class，这点是有很大的区别的。

这下“实际运行的类”能理解了吧，那么上面的那段被拆分的代码也就不难理解了，getClass() 理解了那 clazz.getGenericSuperclass() 也就没什么问题了吧，千万不要以为

clazz.getGenericSuperclass() 获取得到的是 Object 类那就成了，实际上假如当前运行的类是 Base 类的子类，那么 clazz.getGenericSuperclass() 获取得到的就是 Base 类。

再者就是最后一句，(Class<T>) parameterizedType[0]，怎么就知道第一个参数（parameterizedType[0]）就是该泛型的实际类型呢？很简单，因为 Base<T> 的泛型的类型

参数列表中只有一个参数，所以，第一个元素就是泛型 T 的实际参数类型。

其余的已经加了注释，看一下就明白了，这里不多解释，下面 Base 这个类是不是就直接能使用了呢？来看一下就知道了：

package test;
/**
 * -----------------------------------------
 * @描述  测试类
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-25 <p>
 * -----------------------------------------
 */
public class Test {

    public static void main(String[] args){
       
        Base<String> base = new Base<String>();
        System.out.println(base.getEntityClass());                        //打印输出 null
    //    System.out.println(base.getEntityName());                //抛出 NullPointerException 异常
    //    System.out.println(base.getEntitySimpleName()); //抛出 NullPointerException 异常
    }
   
}

从打印的结果来看，Base 类并不能直接来使用，为什么会这样？原因很简单，由于 Base 类中的 clazz.getGenericSuperclass() 方法，如果随随便便的就确定 Base 类的泛型的类型

参数，则很可能无法通过 Base 类中的 if 判断，导致 entityClass 的值为 null，像这里的 Base<String>，String 的 超类是 Object，而 Object 并不能通过 if 的判断语句。

Base 类不能够直接来使用，而是应该通过其子类来使用，Base 应该用来作为一个基类，我们要用的是它的具体的子类，下面来看下代码，它的子类也不是随便写的：

package test;
/**
 * -----------------------------------------
 * @描述  Base类的实现类
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-25 <p>
 * -----------------------------------------
 */
public class Child extends Base<Child>{

}

从上面代码来看，Base 的泛型类型参数就是 Base 的子类本身，这样一来，当使用 Base 类的子类 Child 类时，Base 类就能准确的获取到当前实际运行的类的 Class，来看下怎么使用

package test;
/**
 * -----------------------------------------
 * @描述  测试类
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-25 <p>
 * -----------------------------------------
 */
public class Test {

    public static void main(String[] args){
       
        Child child = new Child();
        System.out.println(child.getEntityClass());
        System.out.println(child.getEntityName());
        System.out.println(child.getEntitySimpleName());
    }
   
}

后台打印输出的结果：

class test.Child
test.Child
Child

好了，文章接近尾声了，如果你能理解透这个例子，你可以将这个思想运用到 DAO 层面上来，以 Base 类作为所有 DAO 实现类的基类，在 Base 类里面实现数据库的 CURD 等基本

操作，然后再使所有具体的 DAO 类来实现这个基类，那么，实现这个基类的所有的具体的 DAO 都不必再实现数据库的 CURD 等基本操作了，这无疑是一个很棒的做法。

（通过反射获得泛型的实际类型参数）补充：

泛型反射的关键是获取 ParameterizedType 接口，再调用 ParameterizedType 接口中的 getActualTypeArguments() 方法就可获得实际绑定的类型。

由于去参数化(擦拭法)，也只有在 超类（调用 getGenericSuperclass 方法） 或者成员变量（调用 getGenericType 方法）或者方法（调用 getGenericParameterTypes 方法）

像这些有方法返回 ParameterizedType 类型的时候才能反射成功。

上面只谈到超类如何反射，下面将变量和方法的两种反射补上：

通过方法，反射获得泛型的实际类型参数：

package test;

import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;

/**
 * -----------------------------------------
 * @描述  测试类
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-26 <p>
 * -----------------------------------------
 */
public class Test {

    public static void main(String[] args){
        /**
         * 泛型编译后会去参数化（擦拭法），因此无法直接用反射获取泛型的参数类型
         * 可以把泛型用做一个方法的参数类型，方法可以保留参数的相关信息，这样就可以用反射先获取方法的信息
         * 然后再进一步获取泛型参数的相关信息，这样就得到了泛型的实际参数类型
         */
        try {
            Class<?> clazz = Test.class; //取得 Class
            Method method = clazz.getDeclaredMethod("applyCollection", Collection.class); //取得方法
            Type[] type = method.getGenericParameterTypes(); //取得泛型类型参数集
            ParameterizedType ptype = (ParameterizedType)type[0];//将其转成参数化类型,因为在方法中泛型是参数,且Number是第一个类型参数
            type = ptype.getActualTypeArguments(); //取得参数的实际类型
            System.out.println(type[0]); //取出第一个元素
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
   
    //声明一个空的方法,并将泛型用做为方法的参数类型
    public void applyCollection(Collection<Number> collection){
       
    }
}

后台打印输出的结果：

class java.lang.Number

通过字段变量，反射获得泛型的实际类型参数：

package test;www.2cto.com

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Collection;
import java.util.Map;

/**
 * -----------------------------------------
 * @描述  测试类
 * @作者  fancy
 * @邮箱  [e-mail]
 * @日期  2012-8-26 <p>
 * -----------------------------------------
 */
public class Test {

    private Map<String, Number> collection;
   
    public static void main(String[] args){
       
        try {
           
            Class<?> clazz = Test.class; //取得 Class
            Field field = clazz.getDeclaredField("collection"); //取得字段变量
            Type type = field.getGenericType(); //取得泛型的类型
            ParameterizedType ptype = (ParameterizedType)type; //转成参数化类型
            System.out.println(ptype.getActualTypeArguments()[0]); //取出第一个参数的实际类型
            System.out.println(ptype.getActualTypeArguments()[1]); //取出第二个参数的实际类型
           
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
   
}

后台打印输出的结果：

class java.lang.String
class java.lang.Number