public Parents() 
    {
         Class<?> c = this.getClass(); //子类创建 会创建父类 子类调用时 此处的this是子类
         Type t = c.getGenericSuperclass(); //获得带有泛型的父类
         if (t instanceof ParameterizedType) 
         {
              Type[] p = ((ParameterizedType) t).getActualTypeArguments();  //取得所有泛型
              this.child= (Class<E>) p[0];
         }

public interface ParameterizedType extends Type {
    //1.获得<>中实际类型
    Type[] getActualTypeArguments();
    //2.获得<>前面实际类型
    Type getRawType();
    //3.如果这个类型是某个类型所属，获得这个所有者类型，否则返回null
    Type getOwnerType();
}

1. List<ArrayList> a1;//这里返回的是，ArrayList，Class类型 
2. List<ArrayList<String>> a2;//这里返回的是ArrayList<String>，ParameterizedType类型  可以继续通过调用getActualTypeArguments获得其泛型类型
3. List<T> a3;//返回的是T，TypeVariable类型 
4. List<? extends Number> a4; //返回的是WildcardType类型 
5. List<ArrayList<String>[]> a5;//GenericArrayType 
要注意，ArrayList与ArrayList<String>的不同。

public static void main(String[] args) throws Exception
    {
        Method method = new Main().getClass().getMethod("test", List.class);//这里的第二个参数，和getRawType()意义类似
        Type[] types = method.getGenericParameterTypes();
        ParameterizedType pType = (ParameterizedType) types[0];
        Type type = pType.getActualTypeArguments()[0];
        System.out.println(type);
        //type是Type类型，但直接输出的不是具体Type的五种子类型，而是这五种子类型以及WildcardType具体表现形式
        System.out.println(type.getClass().getName());
    }
    public void test(List<ArrayList<String>[]> a)
　　 {
    }

Map<Integer, String> maps = new HashMap<>();
ParameterizedType pType = (ParameterizedType) maps.getClass().getGenericSuperclass();//获得HashMap的父类
System.out.println(pType.getRawType());//class java.util.AbstractMap
if(pType.getRawType() instanceof Class){
      System.out.println("true");//true
}
//注意类型（Type）与类（Class）的区别

public class UserDao extends BaseDao<User>{}

我使用的BaseDao是基于DBUtils的，它需要实体的Class对象才能进行通用的查询方法，例如User的Class对象，我们可以通过构造函数，函数参数等手段传递给BaseDao，但是有了反射，可以有更优雅的实现。
public class BaseDao<T> {
    
    private Class<T> clszz;
    
    public BaseDao(){
        Type type = this.getClass().getGenericSuperclass();//拿到带类型参数的泛型父类
        if(type instanceof ParameterizedType){//这个Type对象根据泛型声明，就有可能是4中接口之一，如果它是BaseDao<User>这种形式
            ParameterizedType parameterizedType = (ParameterizedType) type;
            Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();//获取泛型的类型参数数组
            if(actualTypeArguments != null && actualTypeArguments.length == 1){
                if(actualTypeArguments[0] instanceof Class){//类型参数也有可能不是Class类型
                    this.clszz = (Class<T>) actualTypeArguments[0];
                }else{
                    //例如： BaseDao<BaseDao<User>>,获取到的就不是Class,而又是ParameterizedType，即嵌套的
                    ParameterizedType，一层一层剥开，最终是可以得到User的Class对象的
                }
            }
        }
    }
    
    public T get(String sql,Object...params){
        QueryRunner qr = new QueryRunner();
        T obj;
        Connection connection;
        try {
            connection = JdbcUtil.getConnection();
            obj = qr.query(connection,sql,new BeanHandler<T>(clszz),params);
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
        return obj;
    }
}