为什么 Java 允许在任意语句上使用带标签的中断？

Question

我今天刚刚了解到以下 Java 代码是完全合法的：

myBlock: {
    /* ... code ... */

    if (doneExecutingThisBlock())
        break myBlock;

    /* ... more code ... */
}

请注意，myBlock 不是循环 - 它只是我用大括号分隔的代码块。

这似乎是一个相当奇怪的功能。这意味着您可以使用命名的 break 来中断 if 语句或匿名块，尽管您通常不能使用 break在这些上下文中的声明。

我的问题是：这个设计决策有充分的理由吗？也就是说，为什么要这样做，以便只能使用带标签的 break 打破某些封闭语句但不是常规的break？为什么要允许这种行为呢？鉴于 Java 作为一种语言（相对而言）设计良好，我认为这是有原因的，但老实说我想不出一个原因。

Answer 1

这样做似乎是为了简单起见。如果最初标记的break只能中断循环语句，那么语言设计者应该立即清楚该限制是不必要的，语义对于所有语句都是相同的。为了语言规范的经济性和编译器的更简单实现，或者只是出于通用性的习惯，为任何语句定义标记为break，而不仅仅是循环语句。

现在我们可以回顾并判断这个选择。通过赋予程序员额外的表达能力，这对程序员有好处吗？看起来很少，这个功能很少用到。程序员需要学习和理解吗？看来是这样，正如本次讨论所证明的那样。

如果你能回到过去并改变它，你愿意吗？我不能说我会。我们有一种对普遍性的迷恋。

如果在平行宇宙中它仅限于循环语句，那么仍然有机会（可能要小得多）有人在 stackoverflow 上发布问题：为什么它不能处理任意语句？

Answer 2

将其视为从块返回而不是从整个函数返回的 return 语句。适用于对象到 break 分散在任何地方的相同推理也可以适用于允许 return 被允许在除函数末尾之外的任何地方。

Answer 3

goto 的问题是它可以向前跳转，跳过代码。带标签的中断不能做到这一点（它只能向后）。 IIRC C++ 必须处理 goto 跳转过去的代码（自从我关心这个问题以来已经有 17 年多了，所以我不确定我是否记得正确）。

Java 被设计为供 C/C++ 程序员使用，因此做了很多事情来让这些开发人员熟悉它。可以进行从 C/C++ 到 Java 的合理转换（尽管有些事情并非微不足道）。

可以合理地认为，他们将其放入语言中是为了给 C/C++ 开发人员一个安全的跳转（您只能在代码中向后跳转），从而使某些程序员能够更轻松地进行转换。

我从未见过它被使用过，而且在 16 年多的 Java 编程生涯中我也很少见过带标签的中断。

你不能向前突破：

public class Test 
{
    public static void main(final String[] argv) 
    {
        int val = 1;

        X:
        {
            if(argv.length == 0)
            {
                break X;
            }

            if(argv.length == 1)
            {
                break Y;   <--- forward break will not compile
            }
        }

        val = 0;

        Y:
        {
            Sysytem.out.println(val); <-- if forward breaks were allowed this would 
                                          print out 1 not 0.
        }
    }
}

Answer 4

为什么要让您只能使用标记的中断而不是常规的中断来打破某些封闭语句

考虑：

while (true) {
    if (condition) {
        break;
    }
}

如果 break 按照您的建议执行，则此代码将意外执行。休息会变得更加难以使用。

为什么要允许这种行为？

我不使用它，但它是一个功能，并且允许某些独特的控制流构造。我想问你，为什么不允许允许呢？

Answer 5

这个设计决定有充分的理由吗？

是的。因为它有效。

在标记为“break”的情况下，您不需要处于循环或 switch 内，这一事实使您可以表达用其他方式难以表达的内容。 （诚​​然，人们很少以这种方式使用标记的中断......但这不是语言设计的错误。）

在未标记的中断情况下，行为是打破最内层的封闭循环或开关。如果要突破最内层的封闭语句，那么很多事情将更难以表达，并且许多事情可能需要一个标记块。例如：

while (...) {
     /* ... */
     if (something) break;
     /* ... */
}

如果 break 脱离了最内层的封闭语句，那么它就不会脱离循环。

---

还有另一个可能的原因/基本原理。请记住，Java 是一种全新的语言，也是异常和异常处理的较早采用者。

考虑一下：

try {
    /* ... code ... */

    if (doneExecutingThisBlock())
        throw new OuttaHere();

    /* ... more code ... */
} catch (OuttaHere e) {
    /* do nothing */
}

根据教条，这是糟糕的代码。您不应该使用异常来进行“正常”流量控制。

（实际上，由于异常创建和处理的开销，它的效率也非常低。我认为，Java 8 中的异常性能得到了显着提高，但那是大约 20 年后的事了。）

现在想象一下，您是一名语言设计师，并且您觉得你必须提供“异常作为流量控制”反模式的替代方案。 “break to label”结构正是这样做的。将上面的内容与问题中的示例进行比较。

事后看来，这是没有必要的。上述可以通过其他方式完成；即没有标记的中断。实际上，这种构造很少被使用，以至于许多（也许是大多数）程序员甚至不知道 Java 中存在它。

Answer 6

在 Java 之前，多种编程语言已经实现了留下语句序列的功能。两个例子：

Algol-68 有 exit 来终止最小封闭子句的执行（非常宽松地说，开始 ... 结束顺序）。

BLISS 标记了 BEGIN … END 块，并用 LEAVE 语句终止执行。

带标签的实现（如 Java 中）更加灵活，因为它们可以退出嵌套块（或复合语句，或您在选择的语言中对它们的称呼）；如果没有标签，您只能退出一个“级别”。

回答直接的问题“为什么”——因为它被发现在其他先前的语言中是有用的结构。

Answer 7

添加到 Stephen C 的答案中，if (something) 你无法打破嵌套循环。这些情况在数值算法中确实会发生。这里有一个简单的例子 - 如果没有指定的 for，你就无法跳出 i 循环。希望这有帮助。

public class JBreak  {

    private int brj;

    public JBreak (String arg) {
        brj = Integer.parseInt (arg);       
    }

    public void print () {
        jbreak:
        for (int i = 1 ; i < 3 ; i++) {
            for (int j = 0 ; j < 5 ; j++) {
                if ((i*j) == brj)
                    break jbreak;
                System.out.println ("i,j: " + i + "," + j);
    }}}

    public static void main (String[] args) {
        new JBreak(args[0]).print();
}}

Answer 8

它是相当于 goto 的“结构化”，在某些情况下很有用。

我经常使用这样的标签在方法中创建命名子块，以严格限制变量的范围或简单地标记不适合分解为单独函数的代码块。也就是说，我用它来标记一个块，以便保留大括号周围的代码结构。下面是 C 语言中 JNI 调用的示例，我在 Java 中也做了同样的事情：

JNIEXPORT void JNICALL Java_xxx_SystemCall_jniChangePassword(JNIEnv *jep, jobject thsObj,
 jlong handle, jbyteArray rndkey, jbyteArray usrprf, jbyteArray curpwd, jbyteArray newpwd, jint pwdccs, jint tmosec) {
    Message                             rqs,rpy;

    thsObj=thsObj;

    SetupRequest: {
        memset(&rqs,0,sizeof(rqs));
        setOpcode(&rqs,"CHGPWD");
        if(!setField(mFldAndLen(rqs.rnd               ),null                      ,jep,rndkey,"Random Key")) {
            return;
            }
        if(!setField(mFldAndLen(rqs.dta.chgpwd.user   ),&rqs.dta.chgpwd.userLen   ,jep,usrprf,"User Profile")) {
            return;
            }
        if(!setField(mFldAndLen(rqs.dta.chgpwd.curPass),&rqs.dta.chgpwd.curPassLen,jep,curpwd,"Cur Password")) {
            return;
            }
        if(!setField(mFldAndLen(rqs.dta.chgpwd.newPass),&rqs.dta.chgpwd.newPassLen,jep,newpwd,"New Password")) {
            return;
            }
        rqs.dta.chgpwd.ccsid=pwdccs;
        }
    ...

Answer 9

break语句终止带标签的语句；它不会将控制流转移到标签。控制流转移到紧随标记（终止）语句之后的语句。

退出嵌套循环似乎很有用。请参阅 http://download.oracle.com/javase/tutorial/java /nutsandbolts/branch.html

它在语义上与 C# 中是否有相当于 Java 标记中断的功能或解决方法