跳转语句：break、continue、return

r囧r小猫 2023-06-05 11:08 28阅读 0赞

# break、continue、return #

在此将介绍break、continue、return这三种跳转语句，这些语句将控制转移到程序的其他部分。

##### break语句 #####

在Java中，break语句有三种用途。其一，用于终止switch语句中的语句序列；其二，用于退出循环；其三，用作goto语句的"文明"形式。

###### 1、使用break语句退出循环 ######

使用break语句可以强制立即终止循环，绕过条件表达式和循环体中剩余的所有代码。当在循环中遇到break语句时，循环会终止，并且程序控制会继续恢复到循环后的下一条语句。demo如下：

public class BreakLoop {
        
        public static void main(String[] args) {
        
            for(int i=0;i<100;i++){
        
                if(i==10) break;
                System.out.println("i: "+i);
            }
            System.out.println("Loop complete.");
            /*
            输出结果：
            i: 0
            i: 1
            i: 2
            i: 3
            i: 4
            i: 5
            i: 6
            i: 7
            i: 8
            i: 9
            Loop complete.
            可以看出，尽管for循环被设置为从0运行至99，但是当i等于10时，
            break语句提前终止了for循环。
             */
        }
    }

可以在所有Java循环中使用break语句，包括有意设计的无限循环。下面的demo是上面demo的另外一个版本，该版本使用while循环。该版本的输出和刚才显示的完全相同。

public class BreakLoop2 {
        
        public static void main(String[] args) {
        
            int i=0;
            while(i<100){
        
                if(i==10) break;
                System.out.println("i: "+i);
                i++;
            }
            System.out.println("Loop complete");
        }
    }

如何在一系列嵌套的循环中使用break语句，那么break语句只中断最内层的循环。例如：

public class BreakLoop3 {
        
        public static void main(String[] args) {
        
            for(int i=0;i<3;i++){
        
                System.out.print("Pass "+i+": ");
                for(int j=0;j<100;j++){
        
                    if(j==10) break;//terminate loop if j is 10
                    System.out.print(j+" ");
                }
                System.out.println();
            }
            System.out.println("Loops complete.");
            /*
            输出结果：
            Pass 0: 0 1 2 3 4 5 6 7 8 9
            Pass 1: 0 1 2 3 4 5 6 7 8 9
            Pass 2: 0 1 2 3 4 5 6 7 8 9
            Loops complete.
            可以看出，内层循环中的break语句只会导致内层循环终止，对外层循环没有影响。
             */
        }
    }

**break语句的两点总结**  
1、在一个循环中可以出现多条break语句。但是注意，过多的break语句可能会破坏代码的结构。  
2、在某条switch语句中使用的break语句，只会影响该switch语句，不会结束任何外层循环。  
**eg:**  
break语句的设计并不是提供一种终止循环的正常手段，终止循环是条件表达式的目的。只有当发生某些特殊情况时，才当使用break语句取消循环。

###### 2、使用break语句作为goto语句的一种形式 ######

除了用于switch语句和循环外，break语句还可以用于提供goto语句的一种“文明”形式。Java没有提供goto语句，因为goto语句可以随意进入另一个程序分支，并且是一种非结构化的方法。使用goto语句会使代码难于理解和维护，还会妨碍特定的编译器优化。但是，在某些情况下，goto语句对于流程控制很有价值并且结构合法。例如，当退出深度嵌套的一系列循环时，goto语句是很有用的。为了处理这种情况，Java定义了break语句的一种扩展形式。例如，通过使用这种形式的break语句，可以中断一个或多个代码块。这些代码块不必是某个循环或switch语句的一部分，它们可以是任何代码块。此外，可以精确指定准备在什么位置继续执行，因为这种形式的break语句使用标签进行工作。正如即将看到的break语句提供goto语句的优点，而没有goto语句的问题。  
使用标签的break语句的一般形式如下所示：break label;最常见的情况时，label是标识一个代码块的标签的名称。它既可以是一个代码块，也可以是作为另一条语句的目标的代码块。当执行这种形式的break语句时，程序的执行控制会跳出由标签命名的代码块。具有标签命名的代码块必须包含break语句，但是不必立即包含break语句。这意味着可以使用带有标签的break语句退出一系列嵌套的代码，但是不能使用break语句将控制转移出没有包含break语句的代码。  
为了命名代码块，可以在代码块之前放置一个标签。标签可以是任何合法的标识符，后面跟随一个冒号。一旦命名代码块，就可以使用命名标签作为break的目标。这样，就可以在标识的代码块的末端恢复执行。例如，下面的demo展示了三个嵌套的代码块，每个代码块都具有一个标签。break语句导致执行向前跳转，跳至使用second标识的代码块的末端，从而略过两条println()语句。

public class Break {
        
        public static void main(String[] args) {
        
            boolean t = true;
            first:{
        
                second:{
        
                     third:{
        
                         System.out.println("Before the break.");
                         if(t) break second;//break out of second block
                         System.out.println("This won't execute");
                   }
                    System.out.println("This won't execute");
                }
                System.out.println("This is after second block.");
            }
            /*
            执行结果：
            Before the break.
            This is after second block.
             */
        }
    }

带有标签的break语句的最常见用途之一是退出嵌套的循环。下面的demo中，外层循环只执行一次：

public class BreakLoop4 {
        
        public static void main(String[] args) {
        
            outer:for(int i=0;i<3;i++){
        
                System.out.println("Pass "+i+": ");
                for(int j=0;j<100;j++){
        
                    if(j==10)break outer;//exit both loops
                    System.out.print(j+" ");
                }
                System.out.println("This will not print");
            }
            System.out.println("Loops complete.");
            /*
            运行结果：
            Pass 0:
            0 1 2 3 4 5 6 7 8 9 Loops complete.
             */
        }
    }

当内层循环中断外层循环时，两个循环都终止了。eg:这个例子为for语句添加了标签，有一个代码块作为该for语句的目标。  
要牢记，程序的执行控制不能跳转至没有包含break语句的代码块定义的标签。例如下面的程序是无效的，不能通编译：

public class BreakErr {
        
        public static void main(String[] args) {
        
            one:for(int i=0;i<3;i++){
        
                System.out.println("Pass "+i+":");
            }
            for(int j=0;j<100;j++){
        
                if(j==10)break one;//WRONG
                System.out.print(j+" ");
            }
        }
    }

因为具有标签one的循环没有包含break语句，所以不能从该代码块中转移出程序的执行控制。

##### continue语句 #####

当希望继续运行循环，但是停止处理循环体中本次迭代的的剩余代码。continue语句可以执行这种动作。在while和do-while循环中，continue语句导致程序的执行控制直接转移到控制循环的条件表达式。在for循环中，程序的执行控制首先进入for语句的迭代部分，然后到条件表达式。对于这三种循环任何中间代码都会被忽略。  
下面的demo使用continue语句，使得在每行上打印两个数字：

public class Continue {
        
        public static void main(String[] args) {
        
            for (int i=0;i<10;i++){
        
                System.out.print(i+" ");
                if(i%2==0) continue;
                System.out.println();
            }
            /*
            执行结果：
            0 1
            2 3
            4 5 
            6 7
            8 9
             */
        }
    }

上面的代码使用%运算符检查i是否是偶数。如果是偶数，就跳过循环中本次迭代的剩余代码，不打印新行。与break一样，continue也可以指定一个标签，描述继续执行哪个包含它的循环，下面的demo打印0到9的三角乘法表。

public class ContinueLabel {
        
        public static void main(String[] args) {
        
            outer:for(int i=0;i<10;i++){
        
            for(int j=0;j<10;j++){
        
                if(j>i){
        
                    System.out.println();
                    continue outer;
                }
                System.out.print(" "+(i*j));
            }
                System.out.println();
            }
            /*
            执行结果：
             0
             0 1
             0 2 4
             0 3 6 9
             0 4 8 12 16
             0 5 10 15 20 25
             0 6 12 18 24 30 36
             0 7 14 21 28 35 42 49
             0 8 16 24 32 40 48 56 64
             0 9 18 27 36 45 54 63 72 81
             */
        }
    }

在这个例子中的continue语句，终止由j进行计数的循环，并继续执行由i进行计数的循环的下一次迭代。

##### return语句 #####

return语句表示要显示地从方法返回。也就是说，return语句导致程序的执行控制转移给方法的调用者。在方法中，任何时候都可以使用return语句将执行控制转移到方法的调用者。因此，return语句会立即终止执行该语句的方法。下面的demo演示了这一点，在此，return语句将执行控制转移给Java运行时系统，因为main()方法是由运行时系统调用的。

public class Return {
        
        public static void main(String[] args) {
        
            boolean t=true;
            System.out.println("Before the return.");
            if(t) return;
            System.out.println("This won't execute.");
            /*
            执行结果：
             Before the return.
             */
        }
    }

可以看出，没有执行最后的println()语句。只要执行return语句，执行控制就会传递给调用者。此demo中，if(t)语句是必需的。如果没有该语句，Java编译器会发出"unreachable code"错误，因为编译器知道最后的println()语句永远不会执行。为了完成上面的演示，需要防止这个错误发生，在此使用if语句欺骗编译器以达到这一目的。