Java 泛型类以及泛型类获取子类的具体参数类型以及获取子类型具体参数的实例

待我称王封你为后i 2022-07-11 12:07 981阅读 0赞

## 前言： ##

要点都在代码注释中

## 1、泛型类 GenericInterface<T,K> ##

package com.demo.generic;
    
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    
    
    public class GenericInterface<T,K> {//泛型类中有两个泛型参数 T 和 K
    	protected Class<T> tClass;
    	protected Class<K> kClass;
    	
    	//利用反射机制获取泛型类子类泛型参数的具体类型-这个必须写在构造方法中
    	public GenericInterface() {
    		tClass=(Class<T>) getModelClass(tClass, 0);
    		kClass=(Class<K>) 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> 这里有两个泛型形参T和K，Class Name<T> 这里只有1个泛型形参T
    		if(params.length-1<index){
    			modelClass=null;
    		}else{
    			modelClass=(Class) params[index];
    		}
    		
    		return modelClass;
    		
    	}
    	
    	//--将泛型参数按照子类传入值实例化
    	//当在构造方法中为下面泛型参数实例化的时候，可以直接在子类使用 tModel 或者 kMode 处理业务逻辑
    	protected T tModel;
    	protected K kModel;
    	
    	//将子类的泛型类实例化-获取实例化对象的方法
    	public <M> M getModel(Class<M> mClass,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<GenericModel,String> {
    	//泛型参数的具体获取是在泛型类中完成的，这有两个前提
    	//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 Class<T> getEntityClass();

子类继承之

@Override  
protected Class<Book> getEntityClass() \{  
// TODO Auto-generated method stub  
return Book.class;  
\}

枚举类：

public abstract class BaseDaoImpl <T, PK extends Serializable>{
    	protected SessionFactory sessionFactory;
    
    	@Autowired
        public void setSessionFactory(SessionFactory sessionfactory){
    		this.sessionFactory = sessionfactory;
        }
    
        protected Session getSession(){
            return sessionFactory.getCurrentSession();
        }
    	/**
    	 * 获得Dao对于的实体类
    	 * 这个方法需要继承类来实现，return 具体实体类.class
    	 * @return
    	 */
    	abstract protected Class<T> getEntityClass();
    	
    	/**
    	 * @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 BaseDaoImpl<Book,String> implements BookDao {
    
    	@Override
    	public Book get(String pk) {
    		// TODO Auto-generated method stub
    		return super.get(pk);
    	}
    
    	@Override
    	protected Class<Book> getEntityClass() {
    		// TODO Auto-generated method stub
    		return Book.class;
    	}}

涉及到了BookDao，也贴一下

public interface BookDao{
    
    	Book get(String id);
    	
    	List<Book> getListByHql(String hql,Map<String,String> map);
    }