Question

我需要在Java中只在递归方法中执行一次语句，而不使用方法参数中的任何变量，方法外没有任何外部变量，并且语句必须在方法内。

public static boolean recursiveMethod(int x) {
    if (x >= 5) {
        return true;
    }
    boolean isPrintedOnce = false;
    if (isPrintedOnce == false) {
        System.out.println("Printed once!"); // Print this statement only once
        isPrintedOnce = true;
    }
    return recursiveMethod(x + 1);
}

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

这不起作用，因为“boolean isPrintedOnce = false;”执行五次，因此条件语句无用。我把它作为我的输出：

Printed once!
Printed once!
Printed once!
Printed once!
Printed once!
true

编辑：要求是， 1）不能在方法之外使用外部变量 2）在方法参数中不使用变量 3）声明必须在方法内（我的任务需要这个。我可能读错了，因为这些要求似乎不可能，但我相信这些都是要求。）

Answer 1

如何用辅助方法包装它？

public static boolean recursiveMethodHelper(int x) {
    System.out.println("Printed once!");
    return recursiveMethod(x)
}

public static boolean recursiveMethod(int x) {
    if (x >= 5) {
        return true;
    }
    return recursiveMethod(x + 1);
}

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

请注意，这具有始终打印的副作用，即使从一开始就是x>=5。但是，根据您的要求，不会在外部声明变量，也不会添加任何参数。

Answer 2

将System.out.println("Printed once!");放在if (x >= 5)条件中，因为在递归调用中基本情况应该只有一次。

Answer 3

您可以使用此技巧从Exception对象获取堆栈的深度，并仅在特定深度打印：

  public static boolean recursiveMethod(int x) {
    if (x >= 5) {
      return true;
    }
    Exception e = new Exception();
    e.fillInStackTrace();
    if (e.getStackTrace().length == 2) {
      System.out.println("Printed once!"); // Print this statement only once
    }
    return recursiveMethod(x + 1);
  }

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

Answer 4

使用第二个参数的解决方案将在每次外部方法调用时执行一次特殊代码。

public static boolean recursiveMethod(int x, boolean isFirstCall) {
    if (x >= 5) {
        return true;
    }

    if (isFirstCall) {
        System.out.println("Printed once!"); // Print this statement only once

    }
    return recursiveMethod(x + 1, false);
}

public static void main(String[] args) {
    System.out.println(recursiveMethod(0, true));
}

您可以通过重载方法并制作双参数版本private来隐藏此第二个参数。

public static boolean recursiveMethod(int x) {
    recursiveMethod(int x, true);
}

private static boolean recursiveMethod(int x, boolean isFirstCall) {
    if (x >= 5) {
        return true;
    }

    if (isFirstCall) {
        System.out.println("Printed once!"); // Print this statement only once

    }
    return recursiveMethod(x + 1, false);
}

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

Answer 5

您可以使用所谓的辅助方法。这个想法是你让你的递归方法私有（doens实际上需要私有）并接受它作为参数所需的一切。然后创建开发人员使用的第二个方法，并通过传入一组特定的参数来设置递归方法。

让我们看一个例子：

// This method is the one that our developer can use
public static boolean recursiveMethod(int x) {
    recursiveMethod(x, true); // Any time the recursive method is called from here, we know it's the first time!
}

// This is our real one, hidden from view and accessed only by our controlled helper
private static boolean recursiveMethod(int x, boolean firstTime) {
    if (x <= 5) {
        return true;
    }

    if (firstTime) {
        System.out.println("It's the first time!");
    }

    return recursiveMethod(x+1, false); // Anytime this method is called recursively here, we know it isn't the first time!
}

这种辅助方法的好处在于，您不需要对任何内容进行全球化，同时仍然隐藏使用它的人的不必要属性。从他/她的角度来看，它看起来完全一样。

Answer 6

试试此代码

public static boolean recursiveMethod(int x) {
if (x >= 5) {
    return true;
}
boolean isPrintedOnce = false;
if (isPrintedOnce = false) {
    if(x==0){
    System.out.println("Printed once!"); // Print this statement only once
    }
    isPrintedOnce = true;
}
return recursiveMethod(x + 1);
}

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

如何在Java中只在递归方法中执行一次语句？

6 个答案: