package liu.dh.reflect;
import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
public class Demo5_GetGeneric {
/**
  * @param args
  * @throws ClassNotFoundException
  * 重要内容:
  * 获取泛型:通过反射, 获取本类泛型,获取父类泛型
  * 获取本类泛型:
  * 通过Class中TypeValariable[] getTypeParameters(),然后遍历数组,可得到本类泛型
  *
  * 获取父类泛型:
  * 1.子类继承父类时父类添加了泛型:class Ts<Stu> extends Work<Stu>
  * 1.先取得带泛型的父类:通过Type getGenericSuperClass();
  * 2.使用(ParameterizedType)对Type对象向下转型,然后使用ParameterizedType中的
  * Type[] getActualTypeArguments()方法,然后遍历数组,可得到父类泛型.
  * 2.子类继承父类时父类未添加泛型:class Fish extends Creature
  * 1.先取得带泛型的父类:通过Type getGenericSuperClass();
  * 2.向下转型为Class对象,通过Class中TypeValariable[] getTypeParameters(),然后遍历数组,
  * 可得到本类泛型
  *
  * 使用Class 中的getTypeParameters()  按声明顺序返回 TypeVariable 对象的一个数组，
  * 这些对象表示用此 GenericDeclaration 对象所表示的常规声明来声明的类型变量。
  *  Type getGenericSuperclass() 返回表示此 Class 所表示的实体（类、接口、基本类型或 void）的直接超类的 Type
  *  public interface ParameterizedTypeextends Type
  *  ParameterizedType 表示参数化类型，如 Collection<String>。
      Type[] getActualTypeArguments()  返回表示此类型实际类型参数的 Type 对象的数组。
         
         
  */
public static void main(String[] args) throws ClassNotFoundException {
  // TODO Auto-generated method stub
  //获取本类的泛型:
  //获取Creature类泛型
  Class<?> cla =  Class.forName("liu.dh.reflect.Creature");
  System.out.println(cla.getName());//liu.dh.reflect.Creature
  @SuppressWarnings("rawtypes")
  TypeVariable[]tty = cla.getTypeParameters();
  for (TypeVariable<?> typeVariable : tty) {
   System.out.println(typeVariable);//String
  }
  //获取Ts类的泛型
  Ts<Object> ts = new Ts<>();
  Class<? extends Ts> tsl =ts.getClass();
  
  TypeVariable<?>[] TY = tsl.getTypeParameters();
  
  for (TypeVariable<?> typeVariable : TY) {
   System.out.println(typeVariable);//stu
  }
  System.out.println(tsl.getName());//liu.dh.reflect.Ts
  //获取父类泛型:
  //class Ts<Stu> extends Work<Stu>,继承时父类添加泛型,才能使用ParmmeterizedType
  //如果父类未添加泛型<Stu>,侧只能使用TypeParameters();
  
  //获取带泛型的父类:继承父类时class Ts<Stu> extends Work<Stu>父类添加泛型
  Type type2=tsl.getGenericSuperclass();
  System.out.println(type2);
  System.out.println(type2 instanceof ParameterizedType);
  ParameterizedType tys = (ParameterizedType)type2;
  Type[]tt = tys.getActualTypeArguments();
  for (Type type : tt) {
   System.out.println(type);
  }
  
  //获取带泛型的父类
  Class<?> clazz = Class.forName("liu.dh.reflect.Fish");
  Type types = clazz.getGenericSuperclass();
  System.out.println(types);
  //获取父类的泛型:继承父类时class Fish extends Creature,父类未添加泛型
  System.out.println(types instanceof Class);
  Class<?> class1 = (Class<?>)types;//向下转型Class implements Type;
  TypeVariable[]ty = class1.getTypeParameters();
  System.out.println(ty[0].getName());//String
  
  //向下转型问题
Creature<?> aCreature= new Creature<Object>();
System.out.println(aCreature instanceof Fish);//false
Creature<?> creature = new Fish();
System.out.println(creature instanceof Fish);//true
//Fish fish = (Fish)aCreature;//向下转型错误
  System.out.println(types instanceof Class);
  System.out.println(types instanceof ParameterizedType);
  //ParameterizedType type1= (ParameterizedType)types;//向下转型错误
  //Type[]types2 = type1.getActualTypeArguments();
  //System.out.println(((Class<?>)types2[0]).getName());
  
  //获取父类
  Class<?> class2 = clazz.getSuperclass();
  System.out.println(class2.getName());
  
  //获取字段类型
  Field[] field =clazz.getDeclaredFields();
for (Field field2 : field) {
  Type type = field2.getGenericType();
  System.out.println(((Class<?>) type).getName());
  
}
}
}

有时间好好看看，谢谢

努力吧,加油!

加油,奋斗吧

这个必须要好好看看。。。