替代 Java 中的 goto 语句

Question

Java 中 goto 关键字的替代函数是什么？

因为 Java 没有 goto。

Answer 1

虽然一些评论者和反对者认为这不是 goto，但从以下 Java 语句生成的字节码确实表明这些语句确实表达了 goto 语义。

具体来说，第二个示例中的 do {...} while(true); 循环已由 Java 编译器优化，以便不评估循环条件。

向前跳跃

label: {
  // do stuff
  if (check) break label;
  // do more stuff
}

在字节码中：

2  iload_1 [check]
3  ifeq 6          // Jumping forward
6  ..

向后跳跃

label: do {
  // do stuff
  if (check) continue label;
  // do more stuff
  break label;
} while(true);

在字节码中：

 2  iload_1 [check]
 3  ifeq 9
 6  goto 2          // Jumping backward
 9  ..

Answer 2

最简单的是：

int label = 0;
loop:while(true) {
    switch(state) {
        case 0:
            // Some code
            state = 5;
            break;

        case 2:
            // Some code
            state = 4;
            break;
        ...
        default:
            break loop;
    }
}

Answer 3

Java 没有goto，因为它使代码unstructured 和unclear 可读。但是，您可以将break 和continue 用作goto 的文明 形式，而不会出现问题。

---

使用 break 向前跳跃 -

ahead: {
    System.out.println("Before break");
    break ahead;
    System.out.println("After Break"); // This won't execute
}
// After a line break ahead, the code flow starts from here, after the ahead block
System.out.println("After ahead");

输出：

Before Break
After ahead

---

使用 continue 向后跳转

before: {
    System.out.println("Continue");
    continue before;
}

这将导致无限循环，因为每次执行continue before 行时，代码流将从before 重新开始。

Answer 4

使用带标签的中断作为 goto 的替代方法。

Answer 5

public class TestLabel {

    enum Label{LABEL1, LABEL2, LABEL3, LABEL4}

    /**
     * @param args
     */
    public static void main(String[] args) {

        Label label = Label.LABEL1;

        while(true) {
            switch(label){
                case LABEL1:
                    print(label);

                case LABEL2:
                    print(label);
                    label = Label.LABEL4;
                    continue;

                case LABEL3:
                    print(label);
                    label = Label.LABEL1;
                    break;

                case LABEL4:
                    print(label);
                    label = Label.LABEL3;
                    continue;
            }
            break;
        }
    }

    public final static void print(Label label){
        System.out.println(label);
    }

Answer 6

试试下面的代码。它对我有用。

for (int iTaksa = 1; iTaksa <=8; iTaksa++) { // 'Count 8 Loop is  8 Taksa

    strTaksaStringStar[iCountTaksa] = strTaksaStringCount[iTaksa];

    LabelEndTaksa_Exit : {
        if (iCountTaksa == 1) { //If count is 6 then next it's 2
            iCountTaksa = 2;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 2) { //If count is 2 then next it's 3
            iCountTaksa = 3;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 3) { //If count is 3 then next it's 4
            iCountTaksa = 4;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 4) { //If count is 4 then next it's 7
            iCountTaksa = 7;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 7) { //If count is 7 then next it's 5
            iCountTaksa = 5;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 5) { //If count is 5 then next it's 8
            iCountTaksa = 8;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 8) { //If count is 8 then next it's 6
            iCountTaksa = 6;
            break  LabelEndTaksa_Exit;
        }

        if (iCountTaksa == 6) { //If count is 6 then loop 1  as 1 2 3 4 7 5 8 6  --> 1
            iCountTaksa = 1;
            break  LabelEndTaksa_Exit;
        }
    }   //LabelEndTaksa_Exit : {

} // "for (int iTaksa = 1; iTaksa <=8; iTaksa++) {"

Answer 7

Java 中没有任何与goto 概念直接等效的方法。有一些结构可以让您执行一些经典goto 可以执行的操作。

• break 和 continue 语句允许您跳出循环或 switch 语句中的块。
• 带标签的语句和break <label> 允许您跳出任意复合语句到给定方法（或初始化程序块）内的任何级别。
• 如果您标记循环语句，您可以continue <label> 从内部循环继续执行外部循环的下一次迭代。
• 抛出和捕获异常允许您（有效地）跳出方法调用的多个级别。 （但是，异常相对昂贵，被认为是执行“普通”控制流的不好方法¹。）
• 当然还有return。

这些 Java 构造都不允许您向后分支或跳转到代码中与当前语句处于同一嵌套级别的某个点。它们都跳出一个或多个嵌套（范围）级别，并且它们都（除了continue）向下跳。此限制有助于避免旧 BASIC、FORTRAN 和 COBOL 代码中固有的 goto“意大利面条代码”综合症²。

---

^{1- 异常中最昂贵的部分是异常对象及其堆栈跟踪的实际创建。如果你真的，真的需要为“正常”流控制使用异常处理，你可以预先分配/重用异常对象，或者创建一个覆盖fillInStackTrace()方法的自定义异常类。缺点是异常的 printStackTrace() 方法不会为您提供有用的信息……如果您需要调用它们。}

^{2 - 意大利面条代码综合症催生了structured programming 方法，在这种方法中，您限制了对可用语言结构的使用。这可以应用于BASIC、Fortran 和COBOL，但需要谨慎和自律。完全摆脱goto 是一个更实用的解决方案。如果你把它保留在一种语言中，总会有一些小丑会滥用它。}

Answer 8

您可以使用标记为 BREAK 的语句：

search:
    for (i = 0; i < arrayOfInts.length; i++) {
        for (j = 0; j < arrayOfInts[i].length; j++) {
            if (arrayOfInts[i][j] == searchfor) {
                foundIt = true;
                break search;
            }
        }
    }

但是，在设计合理的代码中，您不需要 GOTO 功能。

Answer 9

StephenC 写道：

有两种结构可以让你做一些你想做的事情 可以使用经典的 goto。

还有一个……

马特·沃尔夫写道：

人们总是说从不使用 goto，但我认为有一个 非常好的现实世界用例，这是众所周知和使用的.. 也就是说，确保在从 a 返回之前执行一些代码 功能..通常它释放锁或什么不，但在我的情况下，我会 喜欢能够在返回前跳到休息，所以我可以做 需要强制清理。

try {
    // do stuff
    return result;  // or break, etc.
}
finally {
    // clean up before actually returning, even though the order looks wrong.
}

http://docs.oracle.com/javase/tutorial/essential/exceptions/finally.html

finally 块总是在 try 块退出时执行。这 确保即使出现意外情况也会执行 finally 块 发生异常。但 finally 不仅仅对异常有用 处理——它允许程序员避免清理代码 意外地被返回、继续或中断绕过。进行清理 finally 块中的代码始终是一个好习惯，即使没有 预计会有例外情况。

与 finally 相关的愚蠢面试问题是：如果您从 try{} 块返回，但在 finally{} 中也有返回，那么返回哪个值？

Answer 10

如果你真的想要 goto 语句之类的东西，你总是可以尝试打破命名块。

你必须在块的范围内才能打破标签：

namedBlock: {
  if (j==2) {
    // this will take you to the label above
    break namedBlock;
  }
}

我不会教你为什么要避免使用 goto - 我假设你已经知道答案了。

Answer 11

只是为了好玩，here 是 Java 中的 GOTO 实现。

示例：

   1 public class GotoDemo {
   2     public static void main(String[] args) {
   3         int i = 3;
   4         System.out.println(i);
   5         i = i - 1;
   6         if (i >= 0) {
   7             GotoFactory.getSharedInstance().getGoto().go(4);
   8         }
   9         
  10         try {
  11             System.out.print("Hell");
  12             if (Math.random() > 0) throw new Exception();            
  13             System.out.println("World!");
  14         } catch (Exception e) {
  15             System.out.print("o ");
  16             GotoFactory.getSharedInstance().getGoto().go(13);
  17         }
  18     }
  19 }

运行它：

$ java -cp bin:asm-3.1.jar GotoClassLoader GotoDemo           
   3
   2
   1
   0
   Hello World!

我需要添加“不要使用它！”吗？