Question

好的，我会尝试尽可能具体。

我有一个主类 InputHandler ，下面有五个方法。然后我有六个其他类，每个类下面有大约十个方法。每个类都有自己的main方法，它按顺序调用特定类中的方法。请注意，除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＆gt; helloCountry＆gt; helloTown＆gt; inputHandler （其中a> b表示b扩展a）

因此，这将确保先前类的所有方法都在inputHandler中继承。

现在，正如我所说，inputHandler类本身有自己的main方法。所以，如果我想调用一个属于其中一个大写的方法，我可以使用类似的东西：

...

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

...

现在这是我的问题：如何使用inputHandler按优先级顺序调用相应的main方法。例如，如果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进行排序，您可以相应地调用主要方法！

托马斯＆＃39;方法更好，除非在运行时定义了优先级。

Answer 3

如果在运行时之前不知道优先级，那么这就变成了一个非常古怪的问题......但你可以尝试使用反射，也许是Map＆lt; Integer，Class＆gt;它将保存优先级值到Class的映射。

假设World = 0，Country = 1，Town = 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);

此代码将在运行时按此顺序调用main方法：

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

如何在动态顺序中调用java方法？

3 个答案: