JAVA语言语法_流程控制（part3）_综合

文章目录

- - JAVA语言语法
  - - 三、流程控制
    - - 1、程序流程控制概述
      - 2、顺序结构
      - 3、分支结构
      - 4、分支结构语句练习
      - 5、加深键盘类Scanner类的使用
      - 6、分支结构语句练习2
      - 7、分支结构&switch分支
      - 8、循环结构& for 循环（重点）
      - 9、循环结构&for循环练习
      - 10、循环结构&while循环
      - 11、循环结构&do-while循环
      - 12、循环结构&关键字break
      - 13、循环结构&关键字continue
      - 14、循环结构&关键字return
      - 15、循环结构&嵌套循环（多重循环）
      - 16、循环结构&嵌套循环练习1
      - 17、循环结构&嵌套循环练习2

JAVA语言语法

三、流程控制

1、程序流程控制概述

? 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定给功能的小逻辑模块。

? 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：

   （1）、顺序结构 : 程序从上到下逐行地执行，中间没有任何判断和跳转。?	（2）、分支结构 : 根据条件，选择性地执行某段代码有if、if-else、if-else if..else和switch-case的两种分支语句。?	（3）、循环结构根据循环条件，重复性地执行某段代码;有while、do-while、for三种循环语句;注意: JDK1.5开始提供了foreach的循环, 方便遍历集合、数组元素。

2、顺序结构

在这里插入图片描述

3、分支结构

? （1）、分支语句 if

在这里插入图片描述

? （2）、分支语句 if-else

在这里插入图片描述

? （3）、分支语句 if else if …else

在这里插入图片描述

if -else 使用说明：

(1)、条件表达式必须是布尔表达式(关系表达式或者逻辑表达式)、布尔变量;
(2)、语句块只有一条执行语句时，一队花括号{}可以省略，但是建议保留;
(3)、if-else语句结构，根据需要可以嵌套使用;
(4)、当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略;
(5)、当多个条件是“互斥”关系时，条件判断语句以及执行语句间顺序是无所谓的; 当多个条件是“包含”关系时，可遵循“小上大下/子上父下” （即是范围小的声明在范围大的上面）。

4、分支结构语句练习

代码演示：

package com.rucoding.d5;/*** @author LiuYiXin**/
public class IfelseDemo01 {
    public static void main(String[] args) {
    /** 第一种:* if(条件表达式){* 执行表达式* }* * 第二种:* if(条件表达式){* 执行表达式1* }else{* 执行表达式2* }* * 第三种:* if(条件表达式1){* 执行表达式1* }else if(条件表达式2){* 执行表达式2* }else if(条件表达式3){* 执行表达式3* }* ...* else{* 执行表达式n* }* *///举例1 if语句int heartBeats = 179;if(heartBeats < 60 || heartBeats > 100){
    System.out.println("需要进一步做检查");}System.out.println("检查结束");//举例2 if-else语句int age = 23;if(age < 18){
    System.out.println("你还未成年呢");}else{
    System.out.println("你是成年人了");}//举例3 if else-if ...else 语句if(age < 0){
    System.out.println("数据有误");}else if(age < 18){
    System.out.println("你还是青少年呢");}else if(age < 35){
    System.out.println("你是青壮年呢");}else if(age < 60){
    System.out.println("你是中年人了");}else if(age < 120){
    System.out.println("你已进入老年人生活啦");}else{
     //根据实际的场景，这里的else是可以去除的。System.out.println("你比乌龟还牛。。。");}}
}

5、加深键盘类Scanner类的使用

? 场景模拟：假如需要获取键盘的输入，此时需要从键盘获取不同类型的数据类型，需要使用到Scanner类。

具体步骤:
1.查看API文档;
2.需要导入包: import java.util.Scanner;
3.Scanner的实例化;
4.调用Scanner类的相关方法, 来获取指定的变量。

代码演示：

这里有个疑问：每次运行输出sout语句，光标不能直接换行的哟。能解不？

package com.rucoding.d5;import java.util.Scanner;/*** @author LiuYiXin**/
public class ScannerDemo01 {
    public static void main(String[] args) {
    //声明一个Scanner类Scanner scanner = new Scanner(System.in);System.out.println("请输入你的幸运数字: ");int i = scanner.nextInt();//nextInt()方法接收的是数字类型System.out.println("你输入的幸运数字为：" + i);//录入大一新生的基本信息System.out.println("请输入你的姓名：");String stuName = scanner.next();System.out.println("你输入的姓名为：" + stuName);System.out.println("请输入你的年龄：");int stuAge = scanner.nextInt();System.out.println("你输入的年龄为：" + stuAge);System.out.println("请输入你的体重：");double stuWeight = scanner.nextDouble();System.out.println("你输入的体重为：" + stuWeight);System.out.println("请选择你单身与否？（true(是)/false(否)）");boolean stuIsSingle = scanner.nextBoolean();System.out.println("你选择的是：" +stuIsSingle);//char类型的获取, Scanner类没有提供相应的方法, 只能获取一个字符串System.out.println("请输入你的性别：（男/女）");String stuSex = scanner.next();char stuGender = stuSex.charAt(0);System.out.println("你输入的性别属性为：" + stuGender);}
}

6、分支结构语句练习2

代码演示1：

package com.rucoding.d5;import java.util.Scanner;/*** @author LiuYiXin**/
public class IfelseDemo02 {
    public static void main(String[] args) {
    //分支结构语句if else-if else的练习/*岳小鹏参加数学考试，他和父亲岳不群达成承诺：如果：成绩为100分时，奖励一辆BMW；成绩为(80，99]时，奖励一台iphone xs max；当成绩为[60,80]时，奖励一个 iPad；其它时，什么奖励也没有。请从键盘输入岳小鹏的期末成绩，并加以判断*///声明Scanner类Scanner scanner = new Scanner(System.in); //接收键盘的输入System.inSystem.out.println("请输入岳小鹏的数学成绩：");int stuScore = scanner.nextInt();if(stuScore == 100){
    System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一辆BMW");}else if(stuScore > 80 && stuScore <= 99){
    System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一台iphone xs max");}else if(stuScore >= 60 && stuScore <= 80){
    System.out.println("岳小鹏的数学成绩为：" + stuScore + ",奖励一个iPad");}else if(stuScore < 0 || stuScore > 100){
    System.out.println("输入的数字有误,请检查！");}else{
    System.out.println("不及格, 什么奖励也没有");}}
}

7、分支结构&switch分支

switch - case 结构：
在这里插入图片描述

 注意：
switch-case 结构中的表达式, 只能是如下的六种数据类型之一: byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0)
不能是: boolean、long、float、double类型。

温馨Tip：以下练习题目，可自由安排时间，比如是每日一题，练练手。

练习1代码演示：

package com.rucoding.d5;/*** @author LiuYiXin**/
public class SwitchCaseDemo01 {
    public static void main(String[] args) {
    //分支结构之二: switch-case结构/** 格式定义：* switch(表达式){* case 常量1:* 执行语句1;* //break;* case 常量2:* 执行语句2;* //break;* ...* default:* 执行语句n;* break;* }*///说明://①.根据switch表达式的值, 依次匹配各个case的值,一旦匹配成功,则进入对应的case语句,执行相关语句。//②.当调用完执行的语句后,则仍然继续向下执行其他的case语句,直到遇见break关键字或末尾结束为止。//③.break关键字，可以使用在switch-case语句中，表示一旦执行遇到该关键字，就会跳出switch-case结构。//④.switch-case 结构中的表达式, 只能是如下的六种数据类型之一: byte、short、char、int、枚举类型(JDK5.0)、String类型(JDK7.0)! 不能是: boolean、long、float、double类型//⑤.case之后声明的是常量，不能声明范围。//⑥.break关键字是可选的。//⑦.default：相当于if-else的else default结构是可选的，而且位置是灵活的。//switch-case可以接受的表达式 int类型int num = 2;switch(num){
    case 0:System.out.println("Zero");case 1:System.out.println("One");case 2:System.out.println("Two");break;//此处如果不加break,那么遇到case 2执行的时候,会继续执行其他case语句,直到遇见break或者末尾字节结束才会跳出case 3:System.out.println("Three");break;case 4:System.out.println("Four");break;case 5:System.out.println("Five");break;default:System.out.println("Other...");break;}//switch-case不能接收的表达式类型，比如boolean类型。boolean isOk = true;switch(isOk){
     //无法接收boolean类型的表达式 ,无法通过编译。case true:System.out.println("Ok");break;case false:System.out.println("Not Ok");break;default:System.out.println("信息有误！");break;}//String类型的，自从jdk1.7开始String season = "spring";switch(season){
    case "spring":System.out.println("春暖花开");break;case "summer":System.out.println("夏日炎炎");break;case "autumn":System.out.println("秋高气爽");break;case "winter":System.out.println("白雪皑皑");break;default:System.out.println("输入有误！");break;}}
}

? 练习2代码演示：

package com.rucoding.d5;import java.util.Scanner;/*** @author LiuYiXin**/
public class SwitchCaseDemo02 {
    public static void main(String[] args) {
    /*使用switch 把小写类型的char型转为大写。只转换a, b, c, d, e. 其它的输出“other”。提示：String word = scan.next(); char c = word.charAt(0); switch(c){}*///声明Scanner类Scanner scanner = new Scanner(System.in);System.out.println("输入小写的字母,会自动转为大写：");String str = scanner.next();char lowerWord = str.charAt(0);//获取指定索引位置的值//switch(lowerWord){
    case 'a':System.out.println("A");break;case 'b':System.out.println("B");break;case 'c':System.out.println("C");break;case 'd':System.out.println("D");break;case 'e':System.out.println("E");break;default:System.out.println("other...");break;}}
}

练习3代码演示：

package com.rucoding.d5;/*** @author LiuYiXin**/
public class SwitchCaseDemo03 {
    public static void main(String[] args) {
    /*对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。说明：如果switch-case语句中多个相同语句，可以进行合并。*/int stuScore = 78;switch(stuScore / 10){
    case 0: //switch-case语句中执行多个相同的语句，可以进行合并操作case 1:case 2:case 3:case 4:case 5:System.out.println("不合格");break;case 6:case 7:case 8:case 9:case 10:System.out.println("合格");break;default:System.out.println("输入有误");break;}//优化上述,更优解switch(stuScore / 60){
    case 0:System.out.println("不合格");break;case 1:System.out.println("合格");break;default:System.out.println("输入有误！");break;}}
}

练习4代码演示：

*/
//利用分支结构switch-case实现
int month = 10;
switch(month){
    
case 3:
case 4:
case 5:System.out.println("春季");break;
case 6:
case 7:
case 8:System.out.println("夏季");break;
case 9:
case 10:
case 11:System.out.println("秋季");break;
case 12:
case 1:
case 2:System.out.println("冬季");break;
default:System.out.println("输入月份有误");break;
}

练习5代码演示：

package com.rucoding.d6;import java.util.Scanner;/*** @author LiuYiXin**/
public class SwitchCaseDemo01 {
    public static void main(String[] args) {
    /*编写程序：从键盘上输入2019年的"month"和"day",要求通过程序输出 输入的日期为2019年的第几天。比如2 月 15 日 : 31 + 15 即是1月31天 + 155 7: 31 + 28 +31 +30 + 7...说明：break在switch-case中是可选的。*///声明从键盘接收的Scanner类Scanner scanner = new Scanner(System.in);System.out.println("请输入合法月份month: ");int month = scanner.nextInt();System.out.println("请输入合法日期day: ");int day = scanner.nextInt();//定义总变量天数int sumDays = 0;switch(month){
    
// case 1:
// sumDays = day;
// break;
// case 2:
// sumDays = 31 + day;
// break;
// case 3:
// sumDays = 31 + 28 + day; 
// case 4:
// sumDays = 31 + 28 + 31 + day;写着写着发现太冗余了,很多都是重复的代码 31 + .. day 一直都在，优化一下//我们倒着写case 12:sumDays += 30;case 11:sumDays += 31;case 10:sumDays += 30;case 9:sumDays += 31;case 8:sumDays += 31;case 7:sumDays += 30;case 6:sumDays += 31;case 5:sumDays += 30;case 4:sumDays += 31;case 3:sumDays += 28;case 2:sumDays += 31;case 1:sumDays += day;}	System.out.println("2019年的" + month + "月" + day + "日是第2019年" + sumDays + "天");}
}

练习5代码演示（升级版）：

package com.rucoding.d6;import java.util.Scanner;/*** @author LiuYiXin**/
public class SwitchCaseDemo02 {
    public static void main(String[] args) {
    /*从键盘分别输入年、月、日，判断这一天是当年的第几天注：判断一年是否是闰年的标准：1）可以被4 整除，但是不能被100整除; 【判断方法一】2）可以被400整除。 【或者直接能被400整除 判断方法二】翻译成计算机能听懂的语言：((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))说明:1凡是可以使用switch-case的结构,都可以转换为if-else。反之,不成立。2.我们写分支结构时,当发现既可以使用switch-case,(同时,switch中表达式的取值情况不太多),又可以使用，我们优先选择使用switch-case。原因:switch-case执行效率稍高。*///这题是上面练习4的升级， 多了一个年份， 改变了 2月的天数，闰年的2月是29天，平年的2月是28天//声明一个接收键盘输入的Scanner类Scanner scanner = new Scanner(System.in);System.out.println("请输入合法的年份Year：");int year = scanner.nextInt();System.out.println("请输入合法的年份Month：");int month = scanner.nextInt();System.out.println("请输入合法的年份Day：");int day = scanner.nextInt();//定义变量 ，总天数int sumDays = 0;switch(month){
    case 12:sumDays += 30;case 11:sumDays += 31;case 10:sumDays += 30;case 9:sumDays += 31;case 8:sumDays += 31;case 7:sumDays += 30;case 6:sumDays += 31;case 5:sumDays += 30;case 4:sumDays += 31;case 3://判断输入的year年份是否为闰年if((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)){
    sumDays += 29;}else{
    sumDays += 28;}case 2:sumDays +=31;case 1:sumDays += day;}System.out.println(year + "年的" + month + "月" + day + "日是第" + year + "年" + sumDays + "天");}
}

练习6代码演示：

package com.rucoding.d6;import java.util.Scanner;/*** @author LiuYiXin**/
public class SwitchCaseDemo03 {
    public static void main(String[] args) {
    /*编写一个程序，为一个给定的年份找出其对应的中国生肖。中国的生肖基于12年一个周期，每年用一个动物代表：十二生肖速算法：出生的年份除以12 ，取余数，如果能整除，余数视为0按照下列余数数字对应生肖动物0-猴 1-鸡 2-狗 3-猪 4-鼠 5-牛 6-虎 7-兔 8-龙 9-蛇 10-马 11-羊比如：2019年： 2019 % 12 == 3（余数） ，即是生肖为 猪 *///声明一个键盘接收Scanner类Scanner scanner = new Scanner(System.in);System.out.println("请输入你的诞生年份year: ");int year = scanner.nextInt();//除以12,取余变量int num = year % 12;switch(num){
    case 0:System.out.println("你的生肖为猴");break;case 1:System.out.println("你的生肖为鸡");break;case 2:System.out.println("你的生肖为狗");break;case 3:System.out.println("你的生肖为猪");break;case 4:System.out.println("你的生肖为鼠");break;case 5:System.out.println("你的生肖为牛");break;case 6:System.out.println("你的生肖为虎");break;case 7:System.out.println("你的生肖为兔");break;case 8:System.out.println("你的生肖为龙");break;case 9:System.out.println("你的生肖为蛇");break;case 10:System.out.println("你的生肖为马");break;case 11:System.out.println("你的生肖为羊");break;default:System.out.println("输入信息有误！");break;}}
}

8、循环结构& for 循环（重点）

? 循环结构描述：在某些条件满足的条件下，反复执行特定代码的功能。

? 循环结构的分类：

? （1）、for循环

? （2）、while循环

? （3）、do-while循环

在这里插入图片描述

举例图解：

在这里插入图片描述

9、循环结构&for循环练习

温馨Tip：以下练习题目，可自由安排时间，比如是每日一题，练练手。

练习1代码演示：

package com.rucoding.d5;/*** @author LiuYiXin**/
public class ForDemo01 {
    public static void main(String[] args) {
    //for循环/** for的语法格式* for(①初始化部分;②循环条件部分;④迭代部分){* ③.循环体部分;* }* * 执行过程: ①-②-③-④-②-③-④-②-③-④...*///for循环结构的使用：基本要素：①.初始化条件;②.循环条件;③.循环体部分;④.迭代条件部分。/*结构* for(①;②;④){* ③* }*/for(int i=1;i <= 5;i++){
    System.out.println("HelloWorld");}//练习int num = 1;for(System.out.print('a');num <= 3;System.out.print('c'),num++){
    System.out.print('b'); //输出结果 abcbcbc}System.out.println(); //练习2//遍历100以内的偶数,获取所有偶数的和,输出偶数的个数int sum = 0;int count = 0;for(int i=1;i <= 100;i++){
    if(i % 2 == 0){
    System.out.println(i);sum += i;count++;}}System.out.println("偶数总数和: " + sum + ",偶数个数：" + count);}
}

练习2代码演示：

package com.rucoding.d5;/*** @author LiuYiXin**/
public class ForDemo02 {
    /*编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。*/public static void main(String[] args) {
    for(int i=1;i <= 150;i++){
    System.out.print(i + " ");if(i % 3 == 0){
    System.out.print("foo" + " ");  //不换行}if(i % 5 == 0){
    System.out.print("biz" + " ");}if(i % 7 == 0){
    System.out.print("baz");}System.out.println();  //遍历完一个数，打印换行操作}}
}

练习3代码演示：

package com.rucoding.d6;import java.util.Scanner;/*** @author LiuYiXin**/
public class ForDemo01 {
    public static void main(String[] args) {
    /*输入两个正整数m和n，求其最大公约数和最小公倍数。比如：12和20的最大公约数是4，最小公倍数是60。说明：break关键字的使用*/// 分析一下：//12的约数，1 、2、3、4、6、12 (约束就是能被整除的)//20的约数，1、2、4、5、10、20 //此时最大的公约数肯定不会超过 最小数那个，即12//声明一个键盘的接收类ScannerScanner scanner = new Scanner(System.in);System.out.println("请输入合法的正整数m: ");int m = scanner.nextInt();System.out.println("请输入合法的正整数n: ");int n = scanner.nextInt();//求最大公约数//判断两个数的最小值int min = (m < n) ? m : n; //循环条件部分for(int i=min;i >=1;i--){
     //最大不会超过最小那个12，从12开始递减取最大的if(m % i == 0 && n % i == 0){
    System.out.println(m + "和" + n + "的最大公约数为：" +  i);break;}}//求两个数的最小公倍数//分析一下：//12和20 的公倍数，范围最大在他们俩的乘积 m*n 即是 12*20 = 240，最小的范围大于最大那个值//判断两个数的最大值int max = (m > n) ? m : n;for(int i=max;i <= m*n;i++){
      //循环条件部分if(i % m == 0 && i % n == 0){
    System.out.println("最小的公倍数为：" + i);break;}}}
}

练习4代码演示：

package com.rucoding.d6;/*** @author LiuYiXin**/
public class ForDemo02 {
    /*输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。例如：153 = 1*1*1 + 3*3*3 + 5*5*5*/public static void main(String[] args) {
    //拆解，先取这个数个位、十位、百位for(int i=100;i <=999;i++){
    int ge = i % 10; //个位int shi = i % 100 / 10; //十位int bai = i / 100; //百位
// int result = ge^3 + shi^3 + bai^3; //a^3这样可不行， java中的^符号是来表示"异或" 运算的。int result = ge*ge*ge + shi*shi*shi + bai*bai*bai;if(i == result){
    System.out.println("水仙花数是：" + i);}}}
}

10、循环结构&while循环

基本语法格式：
①.初始化部分
while(②循环条件部分){③.循环体部分;④.迭代部分;
}执行过程描述: ①-②-③-④-②-③-④-...②-③-④说明：
(1)、注意不要忘记声明④迭代部分。否则,循环将不能结束，进入死循环。
(2)、for循环和while循环可以互相转换的。

代码演示：

package com.rucoding.d5;/*** @author LiuYiXin**/
public class WhileDemo01 {
    /** while循环结构的使用：* 基本要素：* ①.初始化条件* ②.循环条件* ③.循环体部分* ④.迭代条件* * 结构：* ①.初始化部分* while(②.循环条件部分){* ③.循环体部分;* ④.迭代部分;* }* * 执行过程描述: ①-②-③-④-②-③-④-...②-③-④* * 说明：* 1、写while循环的，记得别丢了迭代条件，一旦丢失，可能会导致死循环* 2、写程序避免死循环* 3、while循环和for循环可以互相转换。* * 区别: for循环和while循环的初始化条件部分的作用范围不同。*///遍历100以内的偶数,获取所有偶数的和,输出偶数的个数public static void main(String[] args) {
    //改用while循环实现int sum =0;int count =0;int i = 1;while(i <= 100){
    if(i % 2 == 0){
    System.out.println(i);sum += i;count++;}i++;}System.out.println("偶数总和为：" + sum + ",偶数个数为：" + count);}
}

11、循环结构&do-while循环

? 语法格式说明：

在这里插入图片描述

代码演示：

package com.rucoding.d5;/*** @author LiuYiXin**/
public class DoWhileDemo01 {
    /** do-while循环结构的使用* 基本要素：* ①.初始化条件* ②.循环条件 ---> 是boolean类型* ③.循环体* ④.迭代条件* * 结构：* ①.初始化条件* do{* ③.循环体部分* ④.迭代部分* }while(②.循环条件部分);* * 说明：do-while循环至少会执行一次循环体*/public static void main(String[] args) {
    //遍历100以内的所有偶数,并计算所有偶数的和和偶数的个数int sum =0;int count =0;int i = 1;do{
    if(i % 2 == 0){
    System.out.println(i);	sum +=i;count++;}i++;}while(i <= 100);System.out.println("偶数总和为：" + sum + ",偶数个数为：" + count);System.out.println("=======================");int numb = 10; //这里改为12,输出的结果数是一样的（当满足条件运行，输出结果数一致）while(numb > 10){
    System.out.println("while...");numb--;}int numb2 = 10;//这里改为12,输出的是一样的（当满足条件运行，输出结果数一致）do{
    System.out.println("do-while...");numb2--;}while(numb2 > 10);}
}

12、循环结构&关键字break

(1)、break的使用
break语句会终止某个语句块的执行
{    ......break;......
}
(2)、break语句出现在多层嵌套的语句块中的时候，可以通过标签指明要终止的是哪一层的语句块
label1:	{	......
label2:		{	......
label3:			{	......break label2;......}}}

代码演示（break的 “终止” 特征）：

package com.rucoding.d5;import java.util.Scanner;/*** @author LiuYiXin**/
public class BreakDemo01 {
    //break关键字的作用: 出现break的时候，会跳出整个循环体/** 练习从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。说明：1.不在循环条件部分限制次数的结构：while(true) , for(;;)2.结束循环的几种方式：方式一：循环条件部分返回false;方式二：在循环体中，执行break;*/public static void main(String[] args) {
    //声明Scanner类Scanner scanner = new Scanner(System.in);int numZ = 0;int numF = 0;//while循环实现while(true){
    System.out.println("请输入合法的整数：");int num = scanner.nextInt();if(num > 0){
    numZ++;}else if(num < 0){
    numF++;}else{
    break;//跳出整个循环}}System.out.println("输入的正数个数为：" + numZ + ",输入的负数的个数为：" + numF);//for循环实现for(;;){
    System.out.println("请输入合法的整数：");int num = scanner.nextInt();if(num > 0){
    numZ++;}else if(num < 0){
    numF++;}else{
    break;//跳出整个循环}}System.out.println("输入的正数个数为：" + numZ + ",输入的负数的个数为：" + numF);}}

代码演示（break的 “标签label终止” 特征）：

package com.rucoding.d6;/*** @author LiuYiXin**/
public class BreakLableDemo01 {
    public static void main(String[] args) {
    //演示一下break的标签功能label:for(int i = 1;i < 3;i++){
    for(int j = 1;j < 5;j++){
    if(j == 4){
    
// break;break label; //break lable直接结束掉外层循环，终止程序。
// continue label; //下面【13要点】会提及}System.out.print(j);}System.out.println("for lable...");  //break外层循环后，这里不会被打印了。}}
}

13、循环结构&关键字continue

continue语句
(1)、continue只能使用在循环结构中;
(2)、continue语句用于跳过其所在循环语句的一次执行，继续执行下一次循环;
(3)、continue语句出现在多层嵌套循环的语句体时，可以通过标签指明要跳过的是哪一层循环 (重点) : 例题可参考【17、代码4】

代码演示（比较break和continue的区别——重点）：

package com.rucoding.d6;/*** @author LiuYiXin**/
public class BreakContinueDemo01 {
    public static void main(String[] args) {
    //演示break和continue的区别for(int i = 1;i <= 10;i++){
    if(i % 4 == 0){
    
// break; //输出123continue;//输出123567910
// System.out.println();//break、continue后面不能声明执行语句}System.out.println(i);}System.out.println("============分割线=============");for(int i = 1;i <= 4;i++){
    for(int j = 1;j <= 10;j++){
    if(i % 4 == 0){
    
// break; //默认跳出包裹此关键字最近的一层循环continue;}System.out.print(j);}System.out.println();}}
}

小结：

(1)、break只能用于switch语句和循环语句中。
(2)、continue 只能用于循环语句中。
(3)、二者功能类似，但continue是终止本次循环，break是终止本层循环。
(4)、break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
(5)、标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。

14、循环结构&关键字return

return : 并非专门用于结束循环的，它的功能是结束一个方法的。当一个方法执行到一个return语句的时候，这个方法将被结束。
与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环内。

15、循环结构&嵌套循环（多重循环）

1、嵌套循环(多重循环)
(1)、将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for、while、do-while均可以作为外层循环或内层循环。
(2)、实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时候，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
(3)、假设外层循环的次数为m次，内层为n次，则内层循环的实际上执行m*n 次。

代码演示：

package com.rucoding.d6;/*** @author LiuYiXin**/
public class ForDemo03 {
    /** 嵌套循环的使用：* 1、嵌套循环：将一个循环结构A声明再另一个循环结构B结构体中，就形成嵌套循环。* * 2、外层循环：循环结构B* 内层循环：循环结构A* 3、说明：* ①、内层循环遍历一遍，只相当于外层循环循环体执行一次;* ②、假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体实际一共执行m*n次* * 4、技巧* 外层循环控制的是行数，内层循环控制的是列数 (重点记住)*/public static void main(String[] args) {
    //输出五个星号for(int i=1;i <=5;i++){
    System.out.print("*");}System.out.println();//换行//输出5行 5个星号for(int i=1;i <=5;i++){
    for(int j=1;j <=5;j++){
    System.out.print("*");}System.out.println();}System.out.println("========分割线=======");/*打印如下图案1* i(外层控制行数) j(内层j控制列数)** 2 2*** 3 3**** 4 4***** 5 5 即是i=j关系*/for(int i=1;i <=5;i++){
    for(int j=1;j<=i;j++){
    System.out.print("*");}System.out.println();}/* 打印如下图案2***** i(内层循环控制行数) j(内层循环控制列数)**** i = 1 j=5 *** i = 2 j=4****/for(int i=1;i <= 5;i++){
    for(int j=1;j <= (6-i);j++){
    System.out.print("*");}System.out.println();}System.out.println("========分割线=======");/*打印如下图案3* * * * * * * * * * * * * * * * * * * * * * * * * *///分析：/** 先看上半部分*/for(int i=1;i <= 5;i++){
    for(int j=0;j <= (5-i);j++){
    
// System.out.print("-"); //上半部分左边的空格， 可以先当做"-"System.out.print(" ");}//控制星号for(int j=1;j <= i;j++){
    System.out.print("*" + " ");}System.out.println();}//下半部分for(int i=1;i <= 4;i++){
    for(int j=1;j <= i;j++){
    
// System.out.print("-");//下半部分左边的空格， 可以先当做"-"System.out.print(" ");}//控制星号for(int j=1;j <= (5-i);j++){
    System.out.print(" " + "*" );}System.out.println();}}
}

16、循环结构&嵌套循环练习1

练习1：打印九九乘法表

代码演示：

package com.rucoding.d6;/*** @author LiuYiXin**/
public class Print99Demo01 {
    public static void main(String[] args) {
    //打印九九乘法表/** 分析九九乘法表构造* 1 * 1 = 1 i外层控制行数 j内层控制列数* 2 * 1 = 2 2 * 2 = 4* ......* 9 * 1 = 9 9 * 2 = 18 ...... 9 * 9 =81*/for(int i = 1;i <= 9;i++){
    for(int j = 1;j <= i;j++){
    System.out.print(i + " * " + j + " = " + (i*j) + " ");}System.out.println();}}
}

17、循环结构&嵌套循环练习2

练习2：求100000以内的所有质数个数。

代码1：

package com.rucoding.d6;/*** @author LiuYiXin**/
public class PrimeNumberDemo01 {
    //求100000以内的所有质数个数public static void main(String[] args) {
    //分析质数(素数)的特点: 只能被1和它本身整除的自然数。//最小的质数：2/** 拆解：外层循环控制遍历100000以内的数据,内层循环控制 1 到 它本身 减1 的数据* */boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值int count = 0;long startTime = System.currentTimeMillis();//计算程序执行时间for(int i = 2;i <= 100000;i++){
    for(int j = 2;j < i;j++){
    // 此时j的作用：能否被i整除//if(i % j == 0){
     //判断i除以j，只要有一个能整除 就设置isFlag为falseisFlag = false;}}if(isFlag == true){
    
// System.out.println(i);count++;}isFlag = true; //重置flag}long endTime = System.currentTimeMillis();System.out.println("100000以内的质数一共有：" + count + " 个");System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");}
}

【代码1】运行结果:
100000以内的质数一共有：9592 个
计算耗时：11000 毫秒

这运行有点费时，得优化。

代码2【针对代码1的优化】：

注意代码出现的 “优化点1”。

package com.rucoding.d6;/*** @author LiuYiXin**/
public class PrimeNumberDemo02 {
    //求100000以内的所有质数个数public static void main(String[] args) {
    //分析质数(素数)的特点: 只能被1和它本身整除的自然数。//最小的质数：2/** 拆解：外层循环控制遍历100000以内的数据,内层循环控制 1 到 它本身 减1 的数据* */boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值int count = 0;long startTime = System.currentTimeMillis();//计算程序执行时间for(int i = 2;i <= 100000;i++){
    for(int j = 2;j < i;j++){
    // 此时j的作用：能否被i整除//优化点1：这里假如是非质数i为10,//那么此时j的循环是2,3,4..9 (第一个2的时候已经满足除尽的，后面就没必要再执行了)if(i % j == 0){
     //判断i除以j，只要有一个能整除 就设置isFlag为falseisFlag = false;break;//第一个进来满足除尽了，后面的数字没必要再进行一遍整除了。}}if(isFlag == true){
    
// System.out.println(i);count++;}isFlag = true; //重置flag}long endTime = System.currentTimeMillis();System.out.println("100000以内的质数一共有：" + count + " 个");System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");}
}

【代码2】运行结果:
100000以内的质数一共有：9592 个
计算耗时：1078 毫秒

继续观察，发现是还可以进行优化的。

代码3【针对代码2的优化】：

注意代码出现的 “优化点2”。

package com.rucoding.d6;/*** @author LiuYiXin**/
public class PrimeNumberDemo03 {
    //求100000以内的所有质数个数public static void main(String[] args) {
    //分析质数(素数)的特点: 只能被1和它本身整除的自然数。//最小的质数：2/** 拆解：外层循环控制遍历100000以内的数据,内层循环控制 1 到 它本身 减1 的数据* */boolean isFlag = true;//标识是否被除尽，一旦除尽，修改其值int count = 0;long startTime = System.currentTimeMillis();//计算程序执行时间for(int i = 2;i <= 100000;i++){
    for(int j = 2;j <= Math.sqrt(i);j++){
    // 此时j的作用：能否被i整除 //优化点2：这里的循环条件部分(j < i) ,范围可以缩减，刚开始考虑的i/2，缩减了一半，后面再观察考虑一下，开根号可以大大缩减，实在秒啊！//优化点1：这里假如是非质数i为10,//那么此时j的循环是2,3,4..9 (第一个2的时候已经满足除尽的，后面就没必要再执行了)if(i % j == 0){
     //判断i除以j，只要有一个能整除 就设置isFlag为falseisFlag = false;break;//优化点1：第一个进来满足除尽了，后面的数字没必要再进行一遍整除了。}}if(isFlag == true){
    
// System.out.println(i);count++;}isFlag = true; //重置flag}long endTime = System.currentTimeMillis();System.out.println("100000以内的质数一共有：" + count + " 个");System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");}
}

【代码3】运行结果:
100000以内的质数一共有：9592 个
计算耗时：15 毫秒

继续优化，代码看着不太友好。

代码4【针对以上代码的优化】：

Tip：此处利用了continue标签。

package com.rucoding.d6;/*** @author LiuYiXin**/
public class PrimeNumberDemo04 {
    //求100000以内的所有质数个数public static void main(String[] args) {
    //分析质数(素数)的特点: 只能被1和它本身整除的自然数。//最小的质数：2/** 拆解：外层循环控制遍历100000以内的数据,内层循环控制 1 到 它本身 减1 的数据* */int count = 0;long startTime = System.currentTimeMillis();//计算程序执行时间label:for(int i = 2;i <= 100000;i++){
    for(int j = 2;j <= Math.sqrt(i);j++){
    // 此时j的作用：能否被i整除 //if(i % j == 0){
     //判断i除以j，能否除尽continue label;//可以除尽的话，直接后面不用继续了，跳出当前的循环，继续下一次循环}}//能走到这里， 证明已经是质数了。count++;}long endTime = System.currentTimeMillis();System.out.println("100000以内的质数一共有：" + count + " 个");System.out.println("计算耗时：" + (endTime - startTime) + " 毫秒");}
}

【代码4】运行结果:
100000以内的质数一共有：9592 个
计算耗时：13 毫秒