java 获取子类实际的类型名_Java 泛型类 以及 泛型类获取子类的具体参数类型 以及 获取子类型具体参数的实例...

前言：

要点都在代码注释中

1、泛型类 GenericInterface

package com.demo.generic;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

public class GenericInterface{//泛型类中有两个泛型参数 T 和 K

protected ClasstClass;

protected ClasskClass;

//利用反射机制获取泛型类子类泛型参数的具体类型-这个必须写在构造方法中

public GenericInterface() {

tClass=(Class) getModelClass(tClass, 0);

kClass=(Class) getModelClass(kClass, 1);

System.out.println("泛型类构造方法获取到了第一个泛型参数具体类型 tClass="+tClass+"["+this.getClass()+"]");

System.out.println("泛型类构造方法获取到了第二个泛型参数具体类型 kClass="+kClass+"["+this.getClass()+"]");

}

//泛型类作为父类，可以获取子类的所有实际参数的类型

@SuppressWarnings("unchecked")

public Class> getModelClass(Class modelClass,int index){

Type genType = this.getClass().getGenericSuperclass();// 得到泛型父类

Type[] params = ((ParameterizedType) genType).getActualTypeArguments();//一个泛型类可能有多个泛型形参，比如ClassName这里有两个泛型形参T和K，Class Name这里只有1个泛型形参T

if(params.length-1M getModel(ClassmClass,M mModel,int index) {

try {

mModel = (M) getModelClass(mClass,index).newInstance();

} catch (Exception e) {

mModel = null;

}

return mModel;

}

}

2、泛型类的实现类GenericInterfaceImpl

package com.demo.generic;

public class GenericInterfaceImpl extends GenericInterface{

//泛型参数的具体获取是在泛型类中完成的，这有两个前提

//1是子类继承泛型类，且指定了具体的参数的类型

//2泛型类获取子类的具体参数类型必须在构造方法中声明

public GenericInterfaceImpl() {

// TODO Auto-generated constructor stub

System.out.println("泛型类继承类被实例化，泛型参数被具体化"+"["+this.getClass()+"]");

}

}

3、测试类 TestGenericInterfaceImpl

package com.demo.generic;

import org.junit.Test;

public class TestGenericInterfaceImpl {

@Test

public void test1(){

//实例化泛型类的继承类

GenericInterfaceImpl G=new GenericInterfaceImpl();

//让泛型类为第一个泛型参数实例化

GenericModel gModel=G.getModel(G.tClass, G.tModel, 0);

gModel.setName("Jecket");

System.out.println("Model's Name is "+gModel.getName()+"["+this.getClass()+"]");

//让泛型类为第二个泛型参数实例化

String temStr=G.getModel(G.kClass,G.kModel,1);

temStr="Hello World!";

System.out.println("temStr="+temStr+"["+this.getClass()+"]");

}

}

4、运行效果

泛型类构造方法获取到了第一个泛型参数具体类型 tClass=class com.demo.generic.GenericModel[class com.demo.generic.GenericInte

rfaceImpl]

泛型类构造方法获取到了第二个泛型参数具体类型 kClass=class java.lang.String[class com.demo.generic.GenericInterfaceImpl]

泛型类继承类被实例化，泛型参数被具体化[class com.demo.generic.GenericInterfaceImpl]

Model's Name is Jecket[class com.demo.generic.TestGenericInterfaceImpl]

temStr=Hello World![class com.demo.generic.TestGenericInterfaceImpl]

原创声明：http://blog.csdn.net/bestcxx/article/details/54708839

现在增加第二种方法

在思路上，依旧是泛型类和实现类，不同之处在于，这次获取子类的具体实施类型的代码不在泛型类中，而是放在了子类中，准确的说，是子类实现了父类的抽象方法

枚举类

abstract protected ClassgetEntityClass();

子类继承之

@Override

protected ClassgetEntityClass() {

// TODO Auto-generated method stub

return Book.class;

}

枚举类：

public abstract class BaseDaoImpl {

protected SessionFactory sessionFactory;

@Autowired

public void setSessionFactory(SessionFactory sessionfactory){

this.sessionFactory = sessionfactory;

}

protected Session getSession(){

return sessionFactory.getCurrentSession();

}

/**

* 获得Dao对于的实体类

* 这个方法需要继承类来实现，return 具体实体类.class

* @return

*/

abstract protected ClassgetEntityClass();

/**

* @see Session.get(Class,Serializable)

* @param id

* @return 持久化对象

*/

protected T get(PK pk) {

@SuppressWarnings("unchecked")

T entity = (T) getSession().get(getEntityClass(), pk);

return entity;

}}实现类

@Repository

public class BookDaoImpl extends BaseDaoImplimplements BookDao {

@Override

public Book get(String pk) {

// TODO Auto-generated method stub

return super.get(pk);

}

@Override

protected ClassgetEntityClass() {

// TODO Auto-generated method stub

return Book.class;

}}

涉及到了BookDao，也贴一下

public interface BookDao{

Book get(String id);

ListgetListByHql(String hql,Mapmap);

}