如何用IntelliJ IDEA检测子类实例调用父类方法的情况

需求说明 #

需要实现代码检测，禁止子类实例调用父类的特定方法，避免因参数类型与子类泛型约束不匹配，导致意外调用父类方法的情况。

示例代码（泛型场景） #

类定义

abstract class GenericFoo<T> { }

class IntegerFoo extends GenericFoo<Integer> { }

class StringFoo extends GenericFoo<String> { }

abstract class GenericFooPrinter<T> {
  void print(GenericFoo<?> genericFoo) {
    System.out.println("GenericFooPrinter...");
    System.out.println(genericFoo);
  }
}

public class StringFooPrinter extends GenericFooPrinter<String> {
  void print(StringFoo stringFoo) {
    System.out.println("StringFooPrinter...");
    super.print(stringFoo);
  }
}

测试代码

public class FooApplication {
  public static void main(String[] args) {
    var stringFooPrinter = new StringFooPrinter();
    var integerFoo = new IntegerFoo();
    var stringFoo = new StringFoo();

    // 类型不匹配，调用父类GenericFooPrinter.print，需检测拦截
    stringFooPrinter.print(integerFoo);
    // 调用子类StringFooPrinter.print，属于合法情况
    stringFooPrinter.print(stringFoo);
  }
}

实际场景 #

在jOOQ框架中，自动生成的XXXRecord子类重写了父类AbstractRecord的.get()和.set()方法，要求参数TableField<XXXRecord>必须与子类的泛型参数XXXRecord匹配，避免因类型不匹配调用到父类的对应方法，且不能修改方法名。

IntelliJ IDEA实现方案 #

方案1：自定义静态代码检查（最灵活适配场景）

通过IntelliJ的自定义Inspection规则实现精准检测：

1. 打开Settings → Editor → Inspections，点击右上角的+号，选择Custom Inspection
2. 配置检查基础信息：
   • 命名：比如"禁止子类调用不匹配的父类方法"
   • 选择检查类型为Java → Method Calls
3. 编写检查逻辑（基于IntelliJ PSI API）：
   核心逻辑是判断：
   • 当前调用的方法是否属于目标父类（如AbstractRecord或GenericFooPrinter）
   • 调用者实例是否是子类（如XXXRecord或StringFooPrinter）
   • 参数类型是否不符合子类的泛型约束
     伪代码示例：

   // 实际需使用IntelliJ PSI API编写，以下为逻辑示意
   MethodCallExpression methodCall = (MethodCallExpression) element;
   PsiMethod targetMethod = methodCall.resolveMethod();
   if (targetMethod == null) return null;
   
   // 判断父类，比如jOOQ的AbstractRecord
   PsiClass parentClass = targetMethod.getContainingClass();
   if (!"org.jooq.impl.AbstractRecord".equals(parentClass.getQualifiedName())) return null;
   
   // 判断调用者是子类实例
   PsiType callerType = methodCall.getTarget().getType();
   if (callerType == null || callerType.getErasedType().isInterface()) return null;
   PsiClass callerClass = callerType.getErasedType();
   if (!callerClass.isInheritor(parentClass, true)) return null;
   
   // 判断参数是否匹配子类泛型（以.get()为例，参数是TableField）
   PsiParameter[] parameters = targetMethod.getParameterList().getParameters();
   if (parameters.length == 1) {
       PsiType paramType = parameters[0].getType();
       // 检查TableField的泛型参数是否与子类泛型一致
       if (paramType instanceof PsiClassType) {
           PsiType[] typeArgs = ((PsiClassType) paramType).getParameters();
           if (typeArgs.length > 0 && !typeArgs[0].equals(callerClass.getTypeParameters()[0].getType())) {
               return ProblemHighlightType.GENERIC_ERROR_OR_WARNING;
           }
       }
   }
   return null;
   

4. 保存检查规则后，IntelliJ会在代码中实时标记违规调用，还能批量修复。

方案2：优化泛型约束（适用于可修改父类的场景）

如果父类代码可修改（非框架类），可以通过强化泛型约束让编译器提前拦截：

abstract class GenericFooPrinter<T> {
  // 将通配符改为泛型参数T，限制参数类型
  void print(GenericFoo<T> genericFoo) {
    System.out.println("GenericFooPrinter...");
    System.out.println(genericFoo);
  }
}

此时StringFooPrinter继承后，父类print方法仅接受GenericFoo<String>类型参数，integerFoo传入时编译器直接报错，无需额外检查。但jOOQ框架的父类无法修改，此方案仅作参考。

方案3：禁止特定父类方法调用（简单但不够精准）

针对父类的目标方法（如AbstractRecord.get()），设置全局禁止调用，再通过注释豁免合法调用：

1. 找到父类的目标方法，右键选择Inspect Code
2. 在检查结果中，选择该方法的调用，点击Add to banned methods
3. 配置规则时，可添加例外条件，但此方法无法区分参数是否匹配，灵活性不足，仅适用于严格禁止父类方法调用的场景。

内容的提问来源于stack exchange，提问作者akai