java - 通过传递泛型方法进行重构

Question

我已将我的代码简化为:

static private String waitForString(String expected, int attempts) {
  String actual = null;
   for (int i = 0; i < attempts; i++){
      actual = getString();
      if (validateString(actual, expected)) {
         return actual;
      }
   }
   return null;
}

static private int waitForInt(int expected, int attempts) {
   int actual = 0;
   for (int i = 0; i < attempts; i++){
      actual = getInt();
      if (validateInt(actual, expected)) {
         return actual;
      }
   }
   return 0;
}

因为我使用的是同一个循环(并且因为我有多个类，其中有多个相应的“getter”方法和验证方法)我想重构它。我试过这个:

static <T> T helperMethod(Method getMethod, Method validator,T expected, int attempts) {
   T actual = null;
   for (int i = 0; i < attempts; i++){
      actual = method.invoke(null);
      if (validator.invoke(null, actual, expected)) {
         return actual;
      }
   }
   return null;
}

但是我收到以下错误:

actual = method.invoke(null);
error: incompatible types: Object cannot be converted to T 

validator.invoke(null, actual, expected)
error: incompatible types: Object cannot be converted to boolean 

我可以在函数声明中指定只接受具有正确返回类型的方法吗？如果是这样，如何？其他重构方法的想法将不胜感激。

已编辑为了清楚起见，我不是在问如何反射(reflect)方法的返回类型。感谢 VGR 提供的解决方案。

Answer 1

不要使用反射。

反射较慢，开发人员(包括您自己)难以遵循，并且编译器无法检查参数和返回类型是否正确。

在 Java 中实现相当于“指向方法的指针”的正确方法是将各种方法调用包装在一个公共(public)接口(interface)中。从 Java 8 开始，正如 Markus Benko 指出的那样，您应该使用供应商和谓词:

static <T> T waitForValue(Supplier<T> getMethod, BiPredicate<T, T> validator, T expected, int attempts) {
   T actual = null;
   for (int i = 0; i < attempts; i++){
      actual = getMethod.get();
      if (validator.test(actual, expected)) {
         return actual;
      }
   }
   return null;
}

private static String waitForString(String expected, int attempts) {
    return waitForValue(ThisClass::getString, ThisClass::validateString, expected, attempts);
}

private static int waitForInt(int expected, int attempts) {
    return waitForValue(ThisClass::getInt, ThisClass::validateInt, expected, attempts);
}

如果您使用的是旧版本的 Java，您可以做更多的工作来做同样的事情:

private interface Getter<T> {
    T get();
}

private interface Validator<T> {
    boolean test(T actual, T expected);
}

static <T> T waitForValue(Getter<T> getMethod, Validator<T> validator, T expected, int attempts) {
   T actual = null;
   for (int i = 0; i < attempts; i++){
      actual = getMethod.get();
      if (validator.test(actual, expected)) {
         return actual;
      }
   }
   return null;
}

private static String waitForString(String expected, int attempts) {
    Getter<String> getter = new Getter<String>() {
        @Override
        public String get() {
            return getString();
        }
    };
    Validator<String> validator = new Validator<String>() {
        @Override
        public boolean test(String actual, String expected) {
            return validateString(actual, expected);
        }
    };
    return waitForValue(getter, validator, expected, attempts);
}

private static int waitForInt(int expected, int attempts) {
    Getter<Integer> getter = new Getter<Integer>() {
        @Override
        public Integer get() {
            return getInt();
        }
    };
    Validator<Integer> validator = new Validator<Integer>() {
        @Override
        public boolean test(Integer actual, Integer expected) {
            return validateInt(actual, expected);
        }
    };
    return waitForValue(getter, validator, expected, attempts);
}