Java 中的 Break 语句

向所有同事和那些只是感兴趣的人问好。 今天我们来看看Java编程语言的一个特性，即break运算符。这是关于转换运算符主题的第一篇文章，所以如果您喜欢它，我很乐意写更多文章。我想立即指出，本文主要针对初学者开发人员，更高级的学生可能不会在这里找到任何新内容。那么，我们走吧。在Java中，有2种方法可以改变程序指令的执行顺序：跳转语句和异常处理机制。java中有3个跳转操作符：break、continue、return。今天我邀请您仔细了解一下运营商break。异常处理是一个非常广泛的主题，超出了本文的范围。java中break语句的使用方法有3种。第一种也是最流行的方法是使用它break提前退出循环，例如：

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for (int i = 0; i < 10; i++) {
            if (i == number) {
                break;
            }
            System.out.println(i);
        }
        System.out.println("cycle was finished");
    }
}

该示例将显示：

1
2
cycle was finished

这意味着当循环计数器i等于传递的参数number，即数字3时，循环执行提前终止。如果程序有多个嵌套循环，则仅从最内层循环中断输出，例如：

public class SimpleExample {
    public static void main(String[] args) {
        findNumberInLoop(3);
    }
    public static void findNumberInLoop(int number){
        for(int i = 0; i < 5; i++) {
            for (int j =0; j < 10; j++) {
                if(j == number) {
                    break;
                }
                System.out.print(j);
            }
            System.out.println();
        }
        System.out.println("cycles was finished");
    }
}

此示例产生输出：

012
012
012
012
012
cycles was finished

从示例中可以看出，内循环每次在数字 3（参数number）处中断，外循环执行了 5 次，符合预期。在java中，你可以在一个循环中使用多个break语句，但是不推荐这样做，因为代码的可读性和结构会大大降低。第二种用途break是用它来中断branch中语句的执行switch，例如：

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }

    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
                break;
            case 2:
                System.out.println(number*number);
                break;
            case 3:
                System.out.println(number*number);
                break;
        }
        System.out.println("after switch");
    }
}

运行此示例将产生输出：

4
after switch

Break 语句将控制权传递给整个块后面的代码switch。break如果在switch此示例中 未指定：

public class SimpleExample {
    public static void main(String[] args) {
        square(2);
    }
    public static void square(int number){
        switch (number){
            case 1:
                System.out.println(number*number);
            case 2:
                System.out.println(number*number);
            case 3:
                System.out.println(number*number);
        }
        System.out.println("after switch");
    }
}

输出将不会如预期：

4
4
after switch

发生这种情况是因为在执行该块之后，case 2程序继续执行所有后续的case块，这给了我们相应的输出。有时候算子的这个特性switch 对我们来说是有好处的，例如：

public class SimpleExample {
    public static void main(String[] args) {
        compare(2);
        compare(7);
        compare(12);
    }
    public static void compare(int number){
        switch (number){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("number is less than 5 or equal 5");
                break;
            case 6:
            case 7:
            case 8:
            case 9:
                System.out.println("number is greater than 5");
                break;
            default:
                System.out.println("number is less than 0 or greater than 9");
        }
        System.out.println("after switch");
    }
}

该程序将给定数字与数字 5 进行比较，并给出以下输出：

after switch
number is greater than 5
after switch
number is less than 0 or greater than 9
after switch

当第一次调用某个方法时，操作符switch将控制权转移给该操作符，然后再转移给中的case 2操作符。第二个调用与第一个类似，但以 c 开头。第三次调用在所有情况下都没有找到合适的值，因此执行该运算符。第三种方法是使用运算符代替C 运算符。为此，我们将使用带有标签的特殊形式的运算符。这种形式看起来像一个标签 - 这通常是来自 java 命名空间的任何合适的名称，位于代码块之前。而且，给这块代码加上标签后，代码会从相应标签的代码块后面继续执行，例如： breakcase 5case 7defaultbreakgotobreakbreakbreak метка;break

public class SimpleExample {
    public static void main(String[] args) {
        howWeUseLabels(true);
        System.out.println();
        howWeUseLabels(false);
    }
    public static void howWeUseLabels(boolean bool) {
        firstBlock:{
            secondBlock:{
                thirdBlock:{
                    System.out.println("We will see it always");
                    if(bool) {
                        break secondBlock;
                    }
                    System.out.println("We won't see it if bool == true");
                }
                System.out.println("We won't see it if bool == true");
            }
            System.out.println("We will see it always");
        }
    }
}

此示例将产生以下输出：

We will see it always
We will see it always

We will see it always
We won't see it if bool == true
We won't see it if bool == true
We will see it always

在第一个方法调用之后，运算符break将控制转移到块的末尾secondBlock，退出secondBlock和，同时在末尾thirdBlock执行另一个运算符。第二次通话后，所有线路都会显示在屏幕上。标签也可用于指示循环。应该记住，您只能从标签指示的代码块内部转到标签；例如，这样的代码将无法编译： println()firstBlock

public class SimpleExample {
    public static void main(String[] args) {
        label:{
            System.out.println("inside label");
        }
        if(true) {
            break label;
        }
        System.out.println("This is error");
    }
}

关于代码和语句清洁度的注释break：普遍接受的建议是非常小心地使用语句break，因为这种使用break会使循环更难以理解，并迫使程序员查看循环内部以了解其操作的细微差别。有一条启发式规则，break 您可以在较短的循环中更加自信地使用它，而在长而深的嵌套循环中则可以更加谨慎地使用，因为这会增加出现错误的可能性并使其他程序员阅读和理解您的代码变得复杂。正如我上面所写的，在代码中使用大量的break. 表明程序员没有完全理解为什么他要这样编写代码。可能值得考虑通过将其分解为几个较小的循环来重构这样的循环。break 使用标签代替时要小心goto，因为这会使代码结构变得复杂。这就是我今天想告诉你的关于breakjava中的运算符的全部内容。我很乐意接受建设性的批评，如果您感兴趣的话， 我也准备写一篇关于运算符continue和 的续篇。return