Question

重要提示：示例错误，我在底部解释为什么

正如标题所述，问题是要定义一种方法来确定何时以递归方式调用当前执行方法。

我想过有一个“查询方法”，它返回一个布尔值，表明调用者方法（这是调用“查询方法”的方法）是否已经被调用过。

如何检查：只是偷看堆栈跟踪并查看方法我们是否要检查数字两次或更多次 堆栈跟踪。

解释一下，这里是方法的实现及其各自的用法。

这不正确......

public class Test
{
    public static boolean isRecusivelyInvoqued () {
        StackTraceElement[] traces = Thread.currentThread().getStackTrace();
        boolean res = false;
        // the first belong to "getStackTrace" and the second to "isRecusivelyInvoqued" (this method)
        if (traces.length > 2) { 
            String invokedMethodName = traces[2].getMethodName(); // the third is the method we want to check
            for (int i = 3; i < traces.length && !res; i++)
            {
                res = invokedMethodName.equals(traces[i].getMethodName());
                i++;
            }
        }
        return res;
    }

    // this is a recursive method, used to verify the correct functioning
    public static int factorial (int n) {
        System.out.println(isRecusivelyInvoqued());
        if (n == 0) {
            return 1;
        }
        else {
            return n * factorial(n-1);
        }
    }


    public static void main(String[] args)
    {
        System.out.println(factorial(4));
    }

}

我意识到如果不同名称空间（类或实例）中的方法具有相同的名称，它将返回invoquedRecursively。我认为我们得到的一个解决方案是正确的;）jeje。

这对我有用......有没有更好的方法来存档我的目标？如何确定递归调用当前执行方法的时间？

Answer 1

这个怎么样：你的方法将boolean传递给递归方法的下一个调用，告诉它已经递归调用它：

public static int factorial (int n) {
    return privateFactorial(n, false);
}

private static int privatefactorial(int n, boolean calledRecursively) {
    System.out.println(calledRecursively);
    if (n == 0) {
        return 1;
    }
    else {
        return n * privateFactorial(n-1, true);  // tell next invocation here!
    }
}

Answer 2

另一个选择是在递归函数中添加“is_recursively_invoked”参数：

public static int factorial (int n, boolean isInvokedRecursively) {
    System.out.println(isInvokedRecursively);
    if (n == 0) {
        return 1;
    }
    else {
        return n * factorial(n-1, true); // these function calls are recursive
    }
}

并在你的主要：

System.out.println(factorial(4, false));  // this function call isn't recursive

Answer 3

您可以使用static boolean variable来实现此目的这是一个示例：

private static boolean isRecursiveCall = false;
private static int factorial (int n) {
    if (n == 0) {
        return 1;
    }
    else {
        isRecursiveCall = true; 
        return n * factorial(n-1);
    }
}
public static int findFactorial(int n){
     isRecursiveCall = false;
     factorial(n);
}
public static void main(String[] args){
      findFactorial(2);
}

Answer 4

如果您的唯一目标是确定给定方法是否自己调用，那么使用任何字节代码分析框架内省字节代码，并查看是否在方法体内调用了该方法。

如果您需要关于递归深度的数据，那么我将使用AspectJ（或等效的）来使用可以递增计数器的around建议来检测方法。这也消除了方法本身需要做额外工作来支持您的要求。

那就是说，我不明白是否需要这个要求;如果方法产生正确的答案，并且它依赖于递归，那么它使用递归。

检查方法是否以递归方式调用的正确方法

重要提示：示例错误，我在底部解释为什么

4 个答案: