使用基于反射的静态调用而不是接口

Question

我的问题是 Java 中的一般设计问题。在典型的基于控制器的设计（比如 MVC）中，控制器通常创建动作实例并调用从接口实现的方法（比如 Action 接口的 execute()）。

为什么我们需要创建不必要的对象，为什么不使用静态调用并消除实现接口的需要？

就像下面的例子。就像每个 Java 程序都应该有一个 main() 方法一样，每个动作方法都应该有一个 execute()

class MyActionClass {
    public static void execute() {
        System.out.println("Hello from execute()!!");
    }
}

public class StaticTest {

    /**
     * @param args
     * @throws ClassNotFoundException
     * @throws SecurityException
     * @throws NoSuchMethodException
     * @throws InvocationTargetException
     * @throws IllegalArgumentException
     * @throws IllegalAccessException
     */
    public static void main(String[] args) throws ClassNotFoundException,
                        NoSuchMethodException, SecurityException, IllegalAccessException,
                        IllegalArgumentException, InvocationTargetException {
        Class<?> clazz = Class.forName("MyActionClass");
        Method method = clazz.getMethod("execute");
        method.invoke(null);
    }

}

Answer 1

因为反射 API 比使用反射时的方法调用慢得多，所以编译器无法进行任何优化，因为它无法真正了解您在做什么。

通过拥有一个接口和多个实现它的具体类，我们可以获得多态行为的优势。在等式中添加Factory pattern，您可以直接使用您的接口，而无需知道您正在调用哪个具体的类方法。额外的好处是编译器将能够优化您的代码，使其运行速度比使用反射 API 快得多。

从 Java 8 开始，我们可以在接口中实现静态和实例方法。这是一个演示：

public class InterfaceDemo
{
  public static void main(String... args)
  {
    XYZ.executeStatic("Hello");

    XYZ object = new Implementer();
    object.executeInstance("Message");
  }
}

interface XYZ
{
  static void executeStatic(String message)
  {
    System.out.println("Static: " + message);
  }

  default void executeInstance(String message)
  {
    System.out.println("Instance: " + message);
  }
}

class Implementer implements XYZ {}

然后是功能接口，如：

@FunctionalInterface
public interface Returnable<T>
{
  public T value();
}

这允许使用 lambda 表达式创建不同的实现，例如：

Returnable<Integer> integerReturnable = () -> 42;
Returnable<String> stringReturnable = () -> "Hello";

并像这样使用：

System.out.println(integerReturnable.value()); // Prints 42
System.out.println(stringReturnable.value()); // Prints Hello

顺便说一句，如果需要创建很多对象，我们使用Object Pool pattern 或类似的东西，如果有很多类似的对象，我们使用Flyweight Pattern 以在保持速度的同时尽量减少内存使用.