如何以动态顺序调用java方法

Question

好的，我会尽量说得具体一些。

我有一个主类InputHandler和它下面的大约五个方法。然后我有六个其他类，每个类下有大约十个方法。每个类都有自己的主方法，该方法按顺序调用中特定类中的方法。请注意，除了inputHandler之外，每个类都有一个名为priority的变量，该变量存储从0到10的整数。

例如,

    class helloWorld
    {
        String name; int age;
        int priority = 2;
        public static void main()
        {
            setName("John");
            setAge(32);
        }
        public static void setName(String n)
        {
            name = n;
        }
        public static void setAge(int a)
        {
            age = a;
        }
    }

和其他类似的类

但是主类是所有其他类的扩展。所以这个顺序看起来类似于:
helloWorld> helloCountry> helloTown> inputHandler (其中a> b表示b扩展了a)

这将确保在inputHandler中继承前面类的所有方法。

现在，正如我所说，inputHandler类本身有它自己的主方法。因此，如果我想调用一个属于上层类的方法我可以使用如下方式:

...
public static void main()
{
      helloTown.main();
      helloWorld.main();
      helloCountry.main();
}
...

现在这是我的问题:我如何使用inputHandler按优先级顺序调用各自的主方法。例如，如果helloWorld的优先级为2,helloTown的优先级为1,helloCountry的优先级为3，那么应该首先调用helloTown.main()，然后是helloWorld.main()，最后是helloCountry.main()。

我知道这听起来有点混乱，但我相信这是可以做到的。我的做法是首先提取变量的优先级值，并按升序排列，然后根据需要调用方法。任何帮助都是感激的!请随时向我询问更多的细节!

Answer 1

我不太确定我是否正确理解了你的问题，但我会尝试:

如果你有一个层次结构，其中C扩展B, B扩展a，你可以使用实例方法做以下操作:

class A {
  void someMethod() { ... }
}
class B extends A {
  void someMethod() { 
    super.someMethod(); //calls the method from A
    //do whatever B needs to do here
  }
}
class C extends B {
  void someMethod() { 
    //let's change order and first do what C needs to do
    super.someMethod(); //calls the method from B       
  }
}

正如您所看到的，使用super，您可以调用正在扩展的类的方法，并且您可以(几乎)执行任何您喜欢的顺序(在这种情况下，它将是C然后A然后B的逻辑)。

优先级

既然你提到了优先级，我假设你想要有不同的对象，所有的对象都有可能不同的优先级。

在这种情况下，您可以将优先级存储在外部或对象本身(通过方法，字段，注释等)。

另外，你可能想提供一个可以调用的方法的公共接口，例如这样(我将添加一个获得优先级的方法):

interface CommonInterface {
  void someMethod();
  //one way you could do this
  int getPriority();
}
class A implements CommonInterface {
  void someMethod() { ... }
  int getPriority() { return 1; }
}
//same for B and C

然后你得到一些集合，例如一个列表，排序并迭代:

List<CommonInterface> list = ...;
list.add( new A() );
list.add( new B() );
list.add( new C() );
//sort the list, I'll leave the implementation of the comparator for you
Collections.sort(list, new Comparator<CommonInterface>() { 
  public int compare( CommonInterface o1, CommonInterface o2) {
    //compare both objects' priority as needed
    //for more information have a look at the JavaDoc (https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html)
  }
} );
//iterate and call the method
for( CommonInterface instance : list ) {
  instance.someMethod();
}

Answer 2

在inputHandler的主方法中，

获取其他实例的优先级，如helloCountry.getPriority()和

然后将所有优先级保存在散列，列表或其他DS中。

然后对DS进行排序，您可以相应地调用主方法!

Thomas的方法更好，除非优先级是在运行时定义的。

Answer 3

如果直到运行时才知道优先级，这就变成了一个非常古怪的问题…但您可以尝试使用反射，也许是Map<Integer,>，它将保存优先级值到类的映射。

假设世界=0，国家=1，城镇=2

    // Initialize the map
    Map<Integer, Class<?>> callPrio = new HashMap<Integer, Class<?>>();
    callPrio.put(helloWorld.value, helloWorld.class);
    callPrio.put(helloCountry.value, helloCountry.class);
    callPrio.put(helloTown.value, helloTown.class);
    // Invoke "main" methods in order of priority
    for (int i = 0; i < callPrio.size(); i++)
        callPrio.get(i).getMethod("main").invoke(null);

这段代码将在运行时按以下顺序调用主方法:

helloWorld.main()
helloCountry.main()
helloTown.main()