如何查看调用的Java的抽象接口泛型类的参数类型

问题：

LambdaQueryWrapper<Integer> c = new LambdaQueryWrapper<>();

想知道  c.gt 的第一个泛型参数类型 R 是什么？

结论：

gt 是接口 compare 的function，找到 compare 和 lambdaQueryWrapper 的实现链路，肯定有一个地方在 implement compare 的时候，或者 继承 compare 的实现类的时候，指定了 compare的实现类的泛型 R   

而这里是 AbstractLambdaWrapper 在继承 AbstractWrapper（compare的实现类的继承类）的时候，指定了 AbstractWrapper 的泛型类，从而指定了 R 的类型是 String 

同时观察很明显的、复习一下：

Java 可以同时 implement 多个 interface ；

而Java子类只能够继承一个父类，存在单继承局限；

如果想到多重继承 不能直接  C extend A,B 但是可以

class A {}
class B extends A {}
class C extends B {}

实例代码：

package com.example.one.utils;

// 定义了泛型，相当于在class的名称后面<>括号内部定义2个形参
// 这两个形参就是修饰符，可以传递任意java Type定义这个class里面的具体类


// Compare 被抽象类 AbstractWrapper 实现 \  AbstractWrapper又被 AbstractLambdaWrapper 继承 \ LambdaQueryWrapper又继承了 AbstractLambdaWrapper
// 继承的链路  AbstractWrapper > AbstractLambdaWrapper > LambdaQueryWrapper
// 相当于 Compare 有了 3个 实现


// 最终我使用Query类库的时候使用了 LambdaQueryWrapper 的实例
// 而LambdaQueryWrapper在定义的时候定义了AbstractWrapper的第二个java Type是String
// 相当于Compare的泛型第二个类型的R是String

public interface Compare<Children, R> {

    /**
     * ignore
     */
    default Children gt(R column, Object val) {
        return gt(true, column, val);
    }

    /**
     * 大于 &gt;
     *
     * @param condition 执行条件
     * @param column 字段
     * @param val 值
     * @return children
     */
    Children gt(boolean condition, R column, Object val);
}

这个interface的实现：

抽象类实现：

package com.example.one.utils;

// AbstractWrapper 继承了 Wrapper
// 其中 Wrapper 实现了 Compare 和 Join
public abstract class AbstractWrapper<T, R, Children extends AbstractWrapper<T, R, Children>> extends Wrapper<T>
        implements Compare<Children, R>, Join<Children> {
}

抽象类的继承的实现：

package com.example.one.utils;


public class LambdaQueryWrapper<T> extends AbstractLambdaWrapper<T, LambdaQueryWrapper<T>>
        implements Query<LambdaQueryWrapper<T>, T, String> {


    @Override
    public LambdaQueryWrapper<T> gt(String column, Object val) {
        return super.gt(column, val);
    }

    @Override
    public LambdaQueryWrapper<T> gt(boolean condition, String column, Object val) {
        return null;
    }

    public static void main(String[] args) {
        LambdaQueryWrapper<Integer> c = new LambdaQueryWrapper<>();
        c.gt("name", 1);
    }
}

Query 

package com.example.one.utils;

import java.io.Serializable;

public interface Query<Children, T, R> extends Serializable {
}

package com.example.one.utils;

// AbstractLambdaWrapper 继承了 AbstractWrapper
public abstract class AbstractLambdaWrapper<T, Children extends AbstractLambdaWrapper<T, Children>>
        extends AbstractWrapper<T, String, Children> {

}

AbstractLambdaWrapper 在继承 AbstractWrapper 指定第二个R泛型类库是String 所以 ，

AbstractWrapper的继承 AbstractLambdaWrapper 的继承 LambdaQueryWrapper （同时 LambdaQueryWrapper 也是 Query 的实现 ）

最终使用查询构造器 LambdaQueryWrapper 的时候，gt 的形参类型 是 String 

// Compare 被抽象类 AbstractWrapper 实现 \  AbstractWrapper又被 AbstractLambdaWrapper 继承 \ LambdaQueryWrapper又继承了 AbstractLambdaWrapper

// 继承的链路  AbstractWrapper > AbstractLambdaWrapper > LambdaQueryWrapper

// 相当于 Compare 有了 3个 实现