Java中return，break，continue用法总结

Java中return的作用

《Java编程思想：第四版》介绍：return语句作为一个无条件的分支，无需判断条件即可发生。

return语句主要有两个用途：一是用来表示一个方法返回的值（假定没有void返回值）。二是指它导致该方法退出，并返回那个值。根据方法的定义，每一个方法都有返回类型，返回类型可以是基本类型或引用类型。同时每个方法都必须有个结束标志，因此，就出现了return。当方法的返回类型为void时，有个隐含的return语句，可以省略不写。

return语句和其他控制结束语句的区别

Java中结束语句主要有四类：return，break，continue。

（1）return语句：是指结束该方法，继续执行方法后的语句。

java中break和continue可以跳出指定循环，break和continue之后不加任何循环名则默认跳出其所在的循环，在其后加指定循环名，则可以跳出该指定循环（指定循环一般为循环嵌套的外循环）。

（2）break语句：是指在循环中直接退出循环语句（for，while，do-while，foreach），break之后的循环体里面的语句也执行。

（3）continue语句：是指在循环中中断该次循环语句（for，while，do-while，foreach），本次循环体中的continue之后语句不执行，直接跳到下次循环。

break在for循环语句中的使用

使用break的场景有两种：一、switch语句中。二、循环语句。

这里主要说一下break在循环中的应用。

first:for(int j=0; j<5; j++){
    second:for(int i=0; i<5; i++){
        if(i == 0){
            System.out.println(i);
            break first;
        }
    }
    System.out.println("跳出1层for循环到这啦");
    if(j == 0){
        System.out.println("终结者");
        break;
    }
}

输出结果：0

首先 外层循环 j=0，进入内层循环 i=0，此时输出i的值为0。跳出外层循环，所以外层循环中后面的输出语句及判断j=0的语句都不会执行。

 

 loop1:for(int x = 0; x < 4; x++)
        {
            loop2:for (int y = 0; y < 5 ; y++ )
            {
                System.out.println("x="+x+",y="+y);
                if (y==2)
                {
                    break loop1;
                }
            }
        }

x=0,y=0
x=0,y=1
x=0,y=2

continue在for循环语句中的使用

continue跳出指定循环示例代码：

loop1:for(int x = 0; x < 4; x++)
        {
            loop2:for (int y = 0; y < 5 ; y++ )
            {    if (x==2)
                {
                    continue loop1;
                }
                System.out.println("x="+x+",y="+y);
            }
        }

输出结果

x=0,y=0
x=0,y=1
x=0,y=2
x=0,y=3
x=0,y=4
x=1,y=0
x=1,y=1
x=1,y=2
x=1,y=3
x=1,y=4
x=3,y=0
x=3,y=1
x=3,y=2
x=3,y=3
x=3,y=4

return在try-catch-finally语句中的使用

若在 try或catch语句里面有return语句，finally语句和return语句的执行顺序问题：

若有finally语句，则无论如何，都会执行该语句，在try或catch中的return语句会将它的返回值压入栈内，然后执行finally语句。

当finally执行完成后，若finally语句里有return语句，则执行return语句并结束。

若finally没有return语句，则返回被保存的栈里的return语句，再执行。

在压栈时候，要注意压入栈内的值的类型，若是引用类型则引用的值会改变（如下面的案例3），若是变量值，则不会改变（如下面的案例1）。

案例1

public class TestFinally1 {
    public static void main(String[] args) {
        System.out.println("test1:" + testFinally1());
    }

    static int testFinally1() {
        int i = 1;
        try {
            return i;
        } finally {
            System.out.println("in testFinally1():finally 肯定执行");
            i = 48;
        }
    }
}

在testFinally1()中，return i;会将结果i的值，也就是1压入栈。

即使在finally中将i修改了（i=48），也不回对已经压入栈里的1造成任何影响。

输出结果

in testFinally1():finally 肯定执行
test1:1

案例2

public class TestFinally2 {
    public static void main(String[] args) {
        System.out.println("test2:" + testFinally2());
    }


    static String testFinally2() {
        String str = "try";
        try {
            return str;
        } finally {
            System.out.println("in testFinally2():finally 肯定执行");
            str = "finally";
        }
    }
}

 在testFinally2()中，return str;将str的内容压入栈，假设str的内容为0x108(只是一个地址值),通过这个地址值可以找到"try"，那栈里的内容就是0x108。执行str = "finally"，此时str变量的内容可能变为0x237了，这是串"finally"的地址。

方法调用结束后，return时压入栈里的0x108。所以在打印结果时，打印的是通过0x108找到的字符串"try"。

输出结果

in testFinally2():finally 肯定执行
test2:try

案例3

public class TestFinally3 {
    public static void main(String[] args) {
        System.out.println("test3:" + testFinally3());
       
    }

    
 

    static StringBuilder testFinally3() {
        StringBuilder build = new StringBuilder("try ");
        try {
            return build;
        } finally {
            System.out.println("in testFinally3():finally 肯定执行");
            build.append("finally");
            build = new StringBuilder("你猜我是谁！");
        }
    }
}

在testFinally3 ()中，return 压栈的是build变量的值，比如是0x3579，通过这个值可以找到StringBuilder对象。

finally语句块中对这个对象的内容进行了修改。build = new StringBuilder("你猜我是谁！");让build变量指向了一个新的对象，这时候build的值可能是0x4579了。但是，原来的StringBuilder对象仍然在0x3579处，而压栈的正是0x3579啊！方法返回后，得到的返回值0x3579，通过这个引用值找到相应的StringBuilder对象，所以打印的结果是test3:try finally。
 

输出结果

in testFinally3():finally 肯定执行
test3:try finally

案例4

public class TestFinally4 {
    public static void main(String[] args) {
        System.out.println("test4:" + testFinally4());
    }

   static String testFinally4() {
        try {
            return "return in try";
        } finally {
            System.out.println("in testFinally4():finally 肯定执行");
            return "return in finally";
        }
    }
}

在testFinally4()中，finally有return语句，直接返回，方法结束。

输出结果

in testFinally4():finally 肯定执行
test4:return in finally