今天主要学习如下内容
1. 顺序结构和选择结构，选择结构有两种实现方式if和switch，
2. 循环结构
3 .跳转控制语句
JAVA流程控制
- 一个Java程序，通常是由多条符合Java语法规则的语句组成的。
- 一个Java程序的执行，一定意味着多条Java语句的执行。
- 既然是多条Java语句的执行，执行的结果就一定与语句执行的顺序有关，同样的语句，不同的执行顺序，结果可能不同
因此我们需要知道，Java语言如何控制多条语句的执行顺序——通过流程控制(具体来说，是通过3种结构)
1.顺序结构
1 package com.controlflow.sequential; 2 3 /** 6 * 7 * 顺序结构：描述的是Java语句之间，从上到下(或从左到右)依次执行的执行顺序 8 * 9 * 顺序结构是程序中最简单最基本的流程控制，没有特定的语法，就是按照代码书写的顺序执行。 10 11 对于顺序结构而言，写在前面的代码先执行，写在后面的代码后执行 12 */ 13 public class Demo { 14 15 public static void main(String[] args) { 16 int i = 1; 17 int b = 2; 18 } 19 20 }
顺序结构的流程图
2.选择结构
选择结构中的代码顺序和顺序结构中代码的执行顺序有明显的不同：
- 选择结构有特定的语法规则，代码要执行具体的逻辑运算进行判断。
- 逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码。
- Java中，选择结构有2种实现形式，if语句 和switch语句
if语句实现选择结构有3种格式
回忆一下，之前我们所讲解的三元运算符，和if语句的第二种格式所表达的语义是否很相似呢？
if语句第二种格式和三元运算符既然如此相似，是否它们是完全等价的呢？
- 三元运算符的操作都可以使用if语句改进，反之不成立
- 什么时候不成立呢？
1 package com.cskaoyan.controlflow.select; 2 3 import java.util.Scanner; 4 5 /** 15 16 if实现选择结构： 17 1. 单分支的选择结构： 如果..就 18 // 判断提条件的结果只能是true or false 19 if(判断条件) { 20 //语句体 21 } 22 判断条件是由一个 关系表达式 来表示的 23 24 2. 双分支：如果..就。。，否则。。。 25 if (判断条件) { 26 27 } else { 28 29 } 30 31 3. 多分支(各个分支，平行，互斥) 32 if(判断条件1) { 33 条件1语句体 34 } else if (条件2) { 35 条件2语句体 36 } 37 ... 38 else if (条件n) { 39 40 } else { 41 // 第n + 1种情况 42 //当else前都不满足条件的时候，就会执行else中的语句体 43 } 44 45 在绝大部分场景下，三目运算符和if双分支选择结构，都可以相互替代， 46 但是，如果选择结构执行的仅仅只是一个操作，没有返回值，此时if双分支选择结构不可以和三目运算相互替代 47 */ 48 public class Deomo1Select { 49 50 public static void main(String[] args) { 51 52 Scanner scanner = new Scanner(System.in); 53 54 int input = scanner.nextInt(); 55 56 //单分支的if 当用户输入的是正数就输出一下，否则什么都不做 57 //if (input > 0) { 58 // //如果是正数 59 // System.out.println("亲, 您输入了一个整数" + input); 60 //} 61 62 63 //双分支 当用户输入正数的时候输出一下用户输入的正数，当用户输入了非正数提示一下，请用户输入正数 64 //if (input > 0) { 65 // //如果输入的是正数 66 // System.out.println("亲, 您输入了一个整数" + input); 67 //} else { 68 // System.out.println("亲，请重新输入一个正数"); 69 //} 70 71 //多分支 当用户输入正数，0，负数 72 //if (input > 0) { 73 // //正数 74 // System.out.println("亲, 您输入了一个整数" + input); 75 //} else if (input == 0) { 76 // //0 77 // System.out.println("亲, 您输入了一个0"); 78 //} else { 79 // //负数 80 // System.out.println("亲，请重新输入一个数字"); 81 //} 82 83 //关于双分支的if选择结构 84 // 实现两数取大 85 int a = 3; 86 int b = 10; 87 int max; 88 if (a > b) { 89 max = a; 90 } else { 91 max = b; 92 } 93 94 //可以用三目运算符来实现两数取大 95 max = a > b ? a : b; 96 97 //我们发现3目运算符的语义和if双支选择结构，语义几乎完全相同， 98 // 都是非此即彼，但是至少有一种情况，它们不能相互替代 99 if (a > b) { 100 System.out.println("大者是" + a); 101 } else { 102 System.out.println("大者是" + b); 103 } 104 105 //三目运算符的结果一定是一个值 106 //a > b ? System.out.println("大者是" + a) : System.out.println("大者是" + b); 107 108 109 } 110 111 }
练习：
- 键盘录入x的值，计算出y的并输出。
- 键盘录入月份的值，输出对应的季节。获取三个数据中的最大值
1 package com.controlflow.select; 2 3 import java.util.Scanner; 4 5 /** 9 * 练习： 10 1.键盘录入x的值，计算出y的并输出。 11 x和y的关系满足如下： 12 x>=3 y = 2x + 1; 13 -1<=x<3 y = 2x; 14 x<=-1 y = 2x – 1; 15 16 2.键盘录入月份的值，输出对应的季节。 17 12 1 2 冬季 18 3 4 5 春季 19 6 7 8 夏季 20 9 10 11 秋季 21 3.获取三个数据中的最大值 22 */ 23 public class ExerciseIf { 24 25 public static void main(String[] args) { 26 //1.键盘录入x的值，计算出y的并输出。 27 //Scanner scanner = new Scanner(System.in); 28 //int x = scanner.nextInt(); 29 //int y; 30 //if ( x >= 3) { 31 // y = 2 * x + 1; 32 //} else if (x >= -1 && x < 3) { 33 // y = 2 * x; 34 //} else { 35 // // x <= -1 36 // y = 2 * x - 1; 37 //} 38 //System.out.println("x = " + x + "---- y = " + y); 39 40 41 //2.键盘录入月份的值，输出对应的季节。 42 //if (x == 12 || x == 1 || x == 2) { 43 // //冬季 44 // System.out.println("冬季"); 45 //} else if ( x >= 3 && x <= 5) { 46 // //春季 47 // System.out.println("春季"); 48 //} else if ( x >= 6 && x <= 8 ) { 49 // //夏季 50 // System.out.println("夏季"); 51 //} else if ( x >= 9 && x <= 11) { 52 // //秋季 53 // System.out.println("秋季"); 54 //} else { 55 // //应对用户错误的输入 56 // System.out.println("亲，您输入了错误的月份"); 57 //} 58 59 //3.获取三个数据中的最大值 60 int a = 10; 61 int b = 20; 62 int c = 15; 63 64 //if的嵌套来实现 65 //if (a > b) { 66 // // a大 67 // if(a > c) { 68 // // a 最大 69 // System.out.println("最大值是： " + a); 70 // } else { 71 // // c最大 72 // System.out.println("最大值是 " + c); 73 // } 74 //} else { 75 // // b大 76 // if (b > c) { 77 // System.out.println("最大值是： " + b); 78 // } else { 79 // System.out.println("最大值是： " + c); 80 // } 81 //} 82 83 //非嵌套方式 84 int tmp; 85 if ( a > b) { 86 tmp = a; 87 } else { 88 tmp = b; 89 } 90 91 if (tmp > c) { 92 System.out.println(tmp); 93 } else { 94 System.out.println(c); 95 } 96 97 } 98 99 }
switch语句格式：
switch(表达式) {
case 值1：
语句体1;
break;
case 值2：
语句体2;
break;
…
default：
语句体n+1;
break;
}
格式解释：
- switch关键字：表示这是一个switch语句
- switch后的表达式：表示选择条件
- case语句：每个case 语句表示一个分支
- beak语句：表示结束switch语句
- default语句：表示当所有其他的case的分支，都不能匹配
- switch后表达式的值的时候，此时就会执行default分支。
注意事项：
- switch语句后，表达式结果的取值范围？
- case 后的常量取值？
- break可以省略吗？
- default可以省略吗？
- switch语句的结束条件
1 package com.controlflow.select; 2 3 import java.util.Scanner; 4 5 /** 8 * 9 * switch语句格式： switch(表达式) { case 值1： //这个值，代表的一个特定分支 语句体1; //满足条件的分支执行的语句体 break; case 值2： 语句体2; 10 * break; … default： 语句体n+1; break; } 11 * 12 * 格式解释： switch关键字：表示这是一个switch语句 switch后的表达式：表示选择条件 表达式 13 * 14 * case语句：每个case 语句表示一个分支 类比于if所表示的一个分支 beak语句：表示结束 switch语句 default语句：表示当所有其他的case的分支，都不能匹配switch后表达式的值的时候， 15 * 此时就会执行default分支。 有点类似于 if-else多分支中最后的else 16 * 17 * 注意事项： 18 * 1. switch 表达式的结果类型 表达式的取值：byte, short, int, char JDK7以后可以是：String 字符串 19 * 2. case 后的常量取值？case后面的值，不能相同，值必须得是常量值，必须和表达式值的类型相同 20 * 21 * 3. break可以省略吗？语法上可以省略，省略之后，switch实现的就不再是我们所期望的多分支选择结构了，会发生一个现象case穿越 22 * 所谓的case穿越是指：当匹配到switch语句的某个分支，当该分支中不包含break语句，swtich语句不会自动结束， 23 * 紧接着执行，紧邻的下一个case的语句体，最终要么遇到别的分支中的break；结束， 24 * 要么匹配到最后一个case，结束switch语句 25 * 4. default可以省略吗？ 26 * 语法上可以，一把建议不要省略，我们根据实际开发需要来决定 27 * 28 * 5. default分支，必须只能放在最后吗？ 29 * 语法上没有问题，default分支可以放在switch的任意位置，注意default分支， 30 * 如果不在最后，如果不加break，仍然会发生case穿越现象 31 * 32 * 6.switch语句的结束条件 33 */ 34 public class Demo2Switch { 35 36 public static void main(String[] args) { 37 38 Scanner sc = new Scanner(System.in); 39 40 int i = sc.nextInt(); 41 42 switch (i) { 43 44 default: 45 System.out.println("您输入了非 0，1,2的值"); 46 case 0: 47 System.out.println("您输入了0"); 48 break; 49 case 1: 50 System.out.println("您输入了1"); 51 break; 52 case 2: 53 System.out.println("您输入了2"); 54 break; 55 56 57 } 58 59 } 60 61 62 }
练习：
- 模拟做单项选择题，根据你的选择，给出对应的答案。(表达式是字符的情况)
- 键盘录入字符串，根据给定的字符串，来输出你选择的字符串是什么?(表达式是字符串的情况)
- 用switch语句实现键盘录入月份，输出对应的季节 看程序写结果
1 package com.controlflow.select; 2 3 import java.util.Scanner; 4 5 /** 8 * 9 * 1.模拟做单项选择题，根据你的选择，给出对应的答案。(表达式是字符的情况) 2.键盘录入字符串，根据给定的字符串，来输出你选择的字符串是什么?(表达式是字符串的情况) 10 * 3.用switch语句实现键盘录入月份，输出对应的季节 4.看程序写结果 11 */ 12 public class ExerciseSwitch { 13 14 public static void main(String[] args) { 15 16 //1.模拟做单项选择题，根据你的选择，给出对应的答案。 17 //System.out.println("你的女神是？"); 18 //System.out.println("A.高圆圆"); 19 //System.out.println("B.云姐"); 20 //System.out.println("C.沈佳宜"); 21 //System.out.println("D.石原里美"); 22 23 Scanner sc = new Scanner(System.in); 24 //String s = sc.nextLine(); 25 //char c = s.charAt(0); 26 // 27 //switch (c) { 28 // case 'A' : 29 // System.out.println("您的女神是：高圆圆"); 30 // break; 31 // case 'B' : 32 // System.out.println("您的女神是：云姐"); 33 // break; 34 // case 'C' : 35 // System.out.println("您的女神是：沈佳宜"); 36 // break; 37 // case 'D' : 38 // System.out.println("您的女神是：石原里美"); 39 // break; 40 //} 41 42 //2.键盘录入字符串，根据给定的字符串，来输出你选择的字符串是什么?(表达式是字符串的情况) 43 44 //switch (s) { 45 // case "A" : 46 // System.out.println("您的女神是：高圆圆"); 47 // break; 48 // case "B" : 49 // System.out.println("您的女神是：云姐"); 50 // break; 51 // case "C" : 52 // System.out.println("您的女神是：沈佳宜"); 53 // break; 54 // case "D" : 55 // System.out.println("您的女神是：石原里美"); 56 // break; 57 //} 58 59 //3.用switch语句实现键盘录入月份，输出对应的季节 合理利用case穿越 60 //int month = sc.nextInt(); 61 //switch (month) { 62 // case 12: 63 // case 1: 64 // case 2: 65 // System.out.println("冬季"); 66 // break; 67 // case 3: 68 // case 4: 69 // case 5: 70 // System.out.println("春季"); 71 // break; 72 // case 6: 73 // case 7: 74 // case 8: 75 // System.out.println("夏季"); 76 // break; 77 // case 9: 78 // case 10: 79 // case 11: 80 // System.out.println("秋季"); 81 // break; 82 // default: 83 // System.out.println("您输入了错误的月份"); 84 //} 85 86 //4. 看代码，写结果 87 /* int x = 2; 88 int y = 3; 89 switch(x){ 90 default: 91 y++; 92 break; 93 case 3: 94 y++; 95 case 4: 96 y++; 97 } 98 System.out.println("y="+y);*/ 99 100 101 int x = 2; 102 int y = 3; 103 switch(x){ 104 default: 105 y++; 106 case 3: 107 y++; 108 case 4: 109 y++; 110 } 111 System.out.println("y="+y); 112 113 114 } 115 116 }
选择结构有两种实现方式，这两种实现方式，各自适用于什么样的使用场景呢？
if的使用场景
- 针对结果是boolean类型的判断
- 分支对应多个表达式的多个取值
switch的使用场景
- 针对结果是固定类型的判断
- 表达式的取值范围只是固定的离散值集合，分支对应表达式的某一种取值
1 public class compare { 2 3 public static void main(String[] args) { 4 5 //分支对应多个表达式的多个取值 6 int x = 0; 7 int y = 100; 8 9 if (x > 0) { 10 // x > 0 11 } else if (y < 10) { 12 // 0=< y < 10 不对哈这里是我写错了哈 13 // 应该是 x <=0 && y < 10哈，讲课的时候主要想着区别，疏忽了具体代码哈 14 } 15 16 switch (x) { 17 case 0: //一个值对应一个分支 18 break; 19 20 } 21 22 23 } 24 25 }
3.循环结构
在学习循环结构之前，我们首先来简单回顾顺序结构，选择结构中，Java语句的执行特点。
与顺序结构和选择结构不同，循环结构的主要功能是控制Java语句能够重复执行。
如何控制呢？
循环结构，从语法上来讲，有3种实现形式：
-
- for语句
- while语句
- do while语句
但是，不管哪种实现形式，都由4部分组成：
-
- 初始化语句
- 条件判断语句
- 循环体语句
- 循环控制语句
接下来我们首先来分析下，循环结构如何通过，这4个组成部分，完成控制Java语句重复执行的功能。
for 循环语句：
for(初始化语句;判断条件语句;控制条件语句) {
循环体语句;
}
执行流程：
注意事项：
- 判断条件语句的结果的数据类型
- 循环体语句
1 public class Demo1 { 2 3 public static void main(String[] args) { 4 5 int j; 6 //hello 你好 输出10次 7 //1.设定一个计数值：记录你喊了多少次 hello 你好, 而且该计数值的初值为0(初始化语句) 8 //2. 开始重复喊 hello 你好(循环体语句)， 每喊一次 计数值会 + 1(循环体语句，改变循环变量，循环变量就是指喊的次数) 9 //3. 喊hello 你好的计数值(喊的次数) 和 10 比较一下，当 计数值 > 10 结束(结束条件判断) 10 System.out.println("hello 你好"); 11 System.out.println("hello 你好"); 12 System.out.println("hello 你好"); 13 System.out.println("hello 你好"); 14 System.out.println("hello 你好"); 15 System.out.println("hello 你好"); 16 System.out.println("hello 你好"); 17 System.out.println("hello 你好"); 18 System.out.println("hello 你好"); 19 System.out.println("hello 你好"); 20 21 // for 循环实现 22 //for(初始化语句;判断条件语句;控制条件语句) { 23 // 循环体语句; 24 //} 25 for(int i = 1; i <= 10; ++i) { 26 System.out.println("hello 你好 --- " + i); 27 } 28 29 30 //在for循环中定义了变量i，它的作用域，仅仅只在for循环中 31 //System.out.println(i); 32 33 } 34 35 }
练习：
- 请在控制台输出数据1-10
- 请在控制台输出数据10-1
- 求出1-10之间数据之和
- 求出1-100之间偶数和
- 求5的阶乘 在控制台输出所有的”水仙花数”，统计”水仙花数”共有多少个
1 public class Exercise { 2 3 public static void main(String[] args) { 4 //请在控制台输出数据1-10 第一个数1 最后一个数10 5 for (int i = 1; i <= 10 ; i++) { 6 // print 和 println 的区别仅仅在于：println输出之后自动换行 7 //System.out.print(i + " "); 8 } 9 10 //请在控制台输出数据10-1 第一个数10 最后一个数1 11 for (int i = 10; i >= 1 ; --i) { 12 //System.out.print(i + " "); 13 } 14 15 //求出1-10之间数据之和 16 // 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 17 // （1 + 2) + 3 +... 18 // （(（1 + 2） + 3) + 4) + 5 19 // (（（0 + 1） + 2) + 3 + ... ）+10 20 21 //初始和(累和变量) 22 int acc = 0; 23 for (int i = 1; i <= 10; i++) { 24 acc += i; 25 } 26 //System.out.println(acc); 27 28 //求出1-100之间偶数和 29 acc = 0; 30 for (int i = 1; i <= 100 ; i++) { 31 if(i % 2 == 0) { 32 //是偶数 33 acc += i; 34 } 35 } 36 // System.out.println(acc); 37 38 //求5的阶乘 39 // 1 5 * 4 * 3 * 2 * 1 40 int multi = 1; //累积变量，初值为1 41 for (int i = 5; i >= 1 ; i--) { 42 multi *= i; 43 } 44 // System.out.println(multi); 45 46 //在控制台输出所有的”水仙花数” 47 // 1. 这样一个三位数[100 999]： 各位上的数字的立方和的值等于该数字本身 48 int count = 0; 49 for (int i = 100; i < 1000; i++) { 50 //判断一个数字i，是否是水仙花数 51 52 //数位拆解得到各位的数字 53 //个位数字 54 int m = i % 10; 55 //十位数字 56 int n = i / 10 % 10; 57 //百位数字 58 int b = i / 100; 59 60 if (m * m * m + n * n * n + b * b * b == i) { 61 //是水仙花数 62 //System.out.println(i); 63 count++; 64 } 65 } 66 System.out.println(count); 67 68 69 70 } 71 72 }
while循环语句格式：
初始化语句；
while (条件判断语句) {
循环体语句；
}
执行流程：
和for循环一模一样
- for循环和while循环的联系
for循环和while循环几乎可以在任何场景下，作等价替换
- for循环和while循环的区别
直观来说，for循环适合针对一个范围判断进行操作(循环次 数比较明确），for循环适合针对一个范围判断进行操作 (循环次数比较明确）
1 public class WhileDemo { 2 3 public static void main(String[] args) { 4 5 // 我国最高山峰是珠穆朗玛峰：8848m，我现在有一张足够大的纸张，厚度为：0.01m。 6 // 请问，我折叠多少次，就可以保证厚度不低于珠穆朗玛峰的高度? 7 8 //初始化语句 纸张的初始化高度 9 double height = 0.01; 10 int count = 0; 11 while (height < 8848) { 12 height *= 2; 13 count++; 14 } 15 System.out.println("次数是：" + count + "---- height " + height); 16 17 18 } 19 20 }
do …while循环语句格式
初始化语句;
do {
循环体语句;
} while (条件判断)
执行流程： do while 循环结构与while循环结构比，略有不同
1. 执行初始化语句
2. 不管是否满足循环条件，都首先执行一次循环体中的代码
3. 之后的执行流程就和for while
public class DoWhileDemo { public static void main(String[] args) { //先执行循环体，在判断 int i = 10; do { System.out.println(i); i++; } while (i > 11); //对比while循环，先判断在执行循环体 i = 10; while ( i > 11) { System.out.println(i); i++; } } }
3种循环结构的综合比较：
3种循环中，for循环和while循环等价
do … while循环与其他两种循环结构相比，略有不同，因为do…while结构可保证循环体至少执行一次
注意事项：
- 实际使用时，只要达到预期的效果，用哪个都可以
- 如非特殊情况，要注意不要规避死循环问题，如： for(;;) 或 while(true)，
- 死循环并非不能使用(学习多线程时解释)
public class Compare { public static void main(String[] args) { for (;;){ System.out.println("你好 dead loop"); } //while(true) } }
- 请输出一个4行5列的星星(*)图案。
- 请输出如下图形
- *
- **
- ***
- ****
- *****
- 在控制台输出九九乘法表。
1 package com.controlflow.recycle; 2 3 /** 4 * 5 * 1.请输出一个4行5列的星星(*)图案。 6 * ***** 7 * ***** 8 * ***** 9 * ***** 10 2.请输出如下图形 11 * 12 ** 13 *** 14 **** 15 ***** 16 3.在控制台输出九九乘法表。 17 18 */ 19 public class Exercise { 20 21 public static void main(String[] args) { 22 //1.请输出一个4行5列的星星(*)图案。 23 //重复输出5行* 24 //for(int i = 0; i < 4; i++) { 25 // 26 // //重复输出每一行的* 27 // for (int j = 0; j < 5; j++) { 28 // System.out.print("*"); 29 // } 30 // //换行输出下一行 31 // System.out.println(); 32 //} 33 // 34 ////输出三角形的* 35 //for (int i = 1; i <= 5; i++) { 36 // 37 // //控制输出每一行的* 38 // for (int j = 1; j <= i; j++) { 39 // System.out.print("*"); 40 // } 41 // System.out.println(); 42 //} 43 44 //在控制台输出9x9乘法表 45 // 1*1=1 46 // 1*2=2 2*2=4 47 // 1*3=3 2*3=6 3*3=9 48 49 for (int i = 1; i <= 9 ; i++) { 50 51 //控制每一行输出的表达式 52 for (int j = 1; j <= i ; j++) { 53 //内存循环中的每一次执行，输出的是一个表达式 54 System.out.print(j + "x" + i + "=" + j * i + " "); 55 } 56 //换行 57 System.out.println(); 58 59 } 60 } 61 62 }
补充：
1 package com.controlflow.recycle; 2 3 /** 4 * 5 * 有一种循环的写法, 针对数组的遍历： Colletcion 6 * for(数据类型 变量名(标识符) : 数组名) { 7 * 8 * } 9 * 10 */ 11 public class Supplement { 12 13 public static void main(String[] args) { 14 // 定义一个数组 15 int[] array = {1, 2, 3, 4}; 16 17 //普通遍历 18 for (int i = 0; i < 4; i++) { 19 System.out.println(array[i]); 20 } 21 22 // 增强形式for循环 23 // 24 // 1, 2, 3, 4 25 for (int element : array) { 26 System.out.println(element); 27 } 28 29 } 30 31 }
4.跳转控制语句
通过学习循环控制语句，我们已经可以完成控制循环体中的Java代码，重复执行。
但是，循环结构的控制粒度是整个循环语句体，我们可不可以对循环体中的循环体语句，作更加精细的控制呢？ 比如，自己控制循环的结束等。
为了实现对循环结构更加细粒度的控制，我们得通过跳转控制
-
- break 中断
- continue 继续
- return 返回
- break的使用场景：
- 在选择结构的switch语句中
- 在循环语句中（离开使用场景的存在是没有意义的）
- break的作用：
跳出（终止）单层循环（如果有多层循环，只跳出内层）
结束switch语句
- 带标签的跳出(多重循环)
格式：标签名: 循环语句
标签名要符合Java的命名规则
1 public class BreakDemo { 2 3 public static void main(String[] args) { 4 5 //break的基本功能，结束单重循环 6 //for (int i = 1; i <= 10; i++) { 7 // // 输出到5 8 // System.out.println(i); 9 // if(i == 5) { 10 // break; 11 // } 12 //} 13 14 //离开使用场景的break 15 //for (int i = 0; i < 10; i++) { 16 // System.out.println(i); 17 // break; 18 //} 19 20 for (int i = 0; i < 3; i++) { 21 22 for (int j = 0; j < 3; j++) { 23 if( j == 2) { 24 break; 25 } 26 System.out.println("i = " + i + " -- " + "j = " + j); 27 } 28 } 29 System.out.println("---------------------------------------"); 30 // 终止外层循环 31 outer: //给外层循环定义了个标签(标识符) 32 for (int i = 0; i < 3; i++) { 33 for (int j = 0; j < 3; j++) { 34 if( j == 2) { 35 break outer; 36 } 37 System.out.println("i = " + i + " -- " + "j = " + j); 38 } 39 } 40 } 41 42 }
- continue的使用场景：
- 在循环语句中
- 离开使用场景的存在是没有意义的，必须和if连用
- continue的作用：
退出循环的一次迭代过程
也可以使用标签
1 public class ContinueDemo { 2 3 public static void main(String[] args) { 4 5 for (int i = 1; i <= 10; i++) { 6 if(i == 5) { 7 //终止，单重循环的一次循环过程 8 continue; 9 } 10 System.out.println(i); 11 } 12 13 //for (int i = 1; i <= 10; i++) { 14 // //continue 必须和if配合使用 15 // continue; 16 // System.out.println(i); 17 //} 18 19 //i = 0 -- j = 0 20 //i = 0 -- j = 2 21 //i = 1 -- j = 0 22 //i = 1 -- j = 2 23 //i = 2 -- j = 0 24 //i = 2 -- j = 2 25 26 //i = 0 -- j = 0 27 //i = 1 -- j = 0 28 //i = 2 -- j = 0 29 30 outer: 31 for (int i = 0; i < 3; i++) { 32 33 for (int j = 0; j < 3; j++) { 34 if( j == 1) { 35 continue outer; 36 //break; 37 } 38 System.out.println("i = " + i + " -- " + "j = " + j); 39 } 40 41 } 42 43 44 } 45 46 }
return关键字不是为了跳转出循环体 ，更常用的功能是结束一个方法（函数），也就是退出一个方法。 跳转到上层调用的方法。这个在方法的使用那里会在详细的讲解。
演示案例： 结束循环其实是结束了main方法
1 public class ReturnDemo { 2 3 public static void main(String[] args) { 4 5 //return 终止单重循环 6 //for (int i = 1; i <= 10; i++) { 7 // System.out.println(i); 8 // if(i == 5) { 9 // return; 10 // } 11 //} 12 13 //return 终止多重循环 14 for (int i = 0; i < 3; i++) { 15 for (int j = 0; j < 3; j++) { 16 if( j == 2) { 17 return; 18 } 19 System.out.println("i = " + i + " -- " + "j = " + j); 20 } 21 } 22 23 System.out.println(" hello return"); 24 } 25 26 }