动态调用方法名称

Question

假设我有一个名为testMethod（String test1， String test 2）的类和方法。我还有另一个具有不同方法的类，它将调用它所在的方法。请参阅下面的示例

public class functional {
    testMethod(String test1, String test2) {
        reCallMethod();
    }
}
reCallMethod(){
    testMethod(test1, test2); // ------> This has to be dynamic. I've written the method name as "testMEthod" here. But I want it generalized so that I can use this in any method and not just in "testMethod"
}

更多信息 ：-------------------------------

public class test1 {
public void TestCase1(String param1, String param2, String param3) {
        try {
            //Bla Bla Bla
        }
        catch (Throwable t) {
                TestCase_Store_Locator_Verify_Page_Name(param1,param2,param3); //Retry running this method
        }
    }
}
public class test2 {
    public void TestCase2(String param1, String param2, String param3, String param4, String Param5) {
        try {
            //Bla Bla Bla
        }
        catch (Throwable t) {
                TestCase2(param1,param2,param3,param4,param5); //Retry running this method
        }
    }
}

像TestCase1和TestCase2一样，我有500个测试。而不是做上面，我将有一个叫做retryLogic的常用方法，如下所示

public void retryLogic(){
 //Call the test method in the class which this method is placed.
}

So my TestCase1 will look like
    public class test1 {
public void TestCase1(String param1, String param2, String param3) {
        try {
            //Bla Bla Bla
        }
        catch (Throwable t) {
                retryLogic(); //Retry running this method
        }
    }
}

    public void TestCase2(String param1, String param2, String param3) {
        try {
            //Bla Bla Bla
        }
        catch (Throwable t) {
                retryLogic(); //Retry running this method
        }
    }
}

Answer 1

可以使用反射来确定在运行时调用的方法。

有关如何执行此操作的信息，请参阅此帖子：当方法名称为字符串时，如何调用 Java 方法？

Answer 2

看看 Java 的反射功能！

Answer 3

您可以使用 Java 反射来查找类上的方法。因此，clazz.getMethods（） 将返回一个 Array of Method 对象。当你确定你感兴趣的那个时，你会调用method.invoke（...）看到这个： http://docs.oracle.com/javase/tutorial/reflect/class/classMembers.html

Answer 4

在java中，没有办法让变量保存对方法的引用。其他一些语言，例如javascript，允许这样做。

如果您将对象传递到实现具有已知方法名称的接口的"reCallMethod（）"中，则有一个详细的解决方法。通常界面看起来像这样：

public interface CallMe() {
    public Object execute(Object parm1, Object parm2);
}

尽管"执行"上的返回值和参数可能会根据您的需要而有所不同。

然后你的代码看起来像这样：

public class functional {
    final OtherClass otherInstance = new OtherClass();
    testMethod(String test1, String test2) {
        reCallMethod(new CallMe() {
            public Object execute(Object parm1, Object par2) {
                return otherInstance.varyingMethod((String)parm1, (String)parm2); // This is the varying method
            }
        }, text1, text2);
    });
}
reCallMethod(CallMe func, Object parm1, Object parm2){
    func.execute(parm1, parm2);
}

Answer 5

如果你不想使用反射，还有另一种可能性，那就是策略模式。它不提供与反射完全相同的功能，但您确实可以更改在运行时调用的方法。您可以使用将在functional类中调用正确方法的类。

例如，如果functional类具有以下定义：

public class functional {
    public void testMethod (String test1, String test2) {
        reCallMethod();
    }
    public void anotherMethod (String test1, String test2) {
        reCallMethod();
    }
}

您可以有一个定义策略界面的接口：

public interface MyStrategy {
    void callMethod (String param1, String param2);
}

然后实现 2 个不同的策略;每个要调用的方法一个。例如：

public class TestMethodStrategy implements MyStrategy {
    private functional myFunctional;
    public TestMethodStrategy (functional myFunctional) {
        this.myFunctional = myFunctional;
    }
    public void callMethod (String test1, String test2) {
        myFunctional.testMethod (test1, test2);
    }
}

之后您需要做的就是根据当前上下文使用适当的策略。

Answer 6

也许你可以这样做，做同样的事情：

  public void TestCase2(String param1, String param2, String param3) {
        boolean success;
        do {
            success = true;
            try {
                //Bla Bla Bla
            }
            catch (Throwable t) {
                success = false;
            }
        } while (!success);
    }

您甚至可以添加一个计数器来防止它永远运行。只是在 20 次尝试或其他什么之后递增并做break的东西。

关于它的一大好处是，如果您已经编写了其他代码。您只需复制并过去方法顶部的前 4 行，然后复制并过去底部的最后 5 行，并检查现有代码中没有捕获和吃掉任何异常。