getGenericSuperclass与getGenericInterfaces

 

个人理解：这两个方法就是得到超类的泛型类型 和 接口的泛型类型 

代码：

  

1 基础类：

package test2;

public class AccessibleTest extends Person<Test> implements SuperPerson<Person>{

    private int id=1;  
    private String name="网";
    
    public AccessibleTest(){
    	System.out.println( "accesible Test");
    }
    
    public int getId() {
		return id;
	}
 
    public String getName() {
		return name;
	}

	@Override
	public void saySuperPerson(Person t) {
//		 System.out.println( t );
		
	}
}

 

2 超类

package test2;



public class Person<T>   {
 
	public Person(){
		System.out.println( getClass()+"======Person==" );
	}
	private String   name="wangtony" ;
	
	private Integer age =12;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	} 
	


}

 3 接口 

 

package test2;

public interface SuperPerson<T> {

	public void saySuperPerson(T t);
}

 4 测试类 

 

package test2;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Test2 {
 
	
	public static void main(String[] args) throws  Exception  {
		
//		Entity[] e = new Entity[2];
//		e[0] = new Entity();
//		int[] i = {1,3};
		
  
        Class clazz = Class.forName("test2.AccessibleTest");  
        AccessibleTest a = new AccessibleTest(); 
        clazz = a.getClass();
		Type genType = clazz.getGenericSuperclass(); //得到这个类的父类 的参数类型

		
		if (genType instanceof ParameterizedType) { //如果是 泛型的参数类型 ，就得到泛型类型 
			Type[] params = ((ParameterizedType) genType).getActualTypeArguments(); //强转换为参数类型 
			for(Type t : params ){
				System.out.println( t );
			}
			System.out.println( "==========");
		}
		
		//得到接口的泛型类型 
		Type[] type1 = clazz.getGenericInterfaces();
		if( type1!=null && type1.length>0 ){ 
			for(int i=0;i<type1.length;i++ ){ //循环泛型类型 
				
				//如果得到的泛型类型是 ParameterizedType（参数化类型）类型的话
				if(ParameterizedType.class.isAssignableFrom( type1[i].getClass()  )  ){ 
					ParameterizedType ptype = (ParameterizedType)type1[i];//将类型转换为 参数类型类 
					Type[] iType = ptype.getActualTypeArguments(); //得到  泛型类型的实际  类型 
					for(Type p1 : iType){
						System.out.println(p1 +"=======" );
					}
				}
			}
		}

	}

 
}