流程控制语句

一、流程控制语句的介绍

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

程序设计中规定的`三种`流程结构，即：

顺序结构
- 程序从上到下逐行地执行，中间没有任何判断和跳转。
分支结构
- 根据条件，选择性地执行某段代码。
- 有if…else和switch-case两种分支语句。
循环结构
- 根据循环条件，重复性的执行某段代码。
- 有for、while、do-while三种循环语句。
- 补充：JDK5.0 提供了`foreach`循环，方便的遍历集合、数组元素。（第12章集合中讲解）

二、顺序结构

顺序结构就是程序从上到下逐行地执行。表达式语句都是顺序执行的。并且上一行对某个变量的修改对下一行会产生影响。

public class StatementTest{
   public static void main(String[] args){
       int x = 1;
       int y = 2;
       System.out.println("x = " + x);
System.out.println("y = " + y);
//对x、y的值进行修改
x++;
y = 2 * x + y;
x = x * 10;
System.out.println("x = " + x);
System.out.println("y = " + y);
}
}

java中定义变量时采用合法的前向引用。如：

public static void main(String[] args) {

//正确形式
int num1 = 12;
int num2 = num1 + 2;

//错误形式

int num2 = num1 + 2;
int num1 = 12;
}

三、分支结构

1.if..else条件判断结构

a）结构1：单分支条件判断：if

格式：

if(条件表达式)｛
语句块;
｝

说明：条件表达式必须是布尔表达式（关系表达式或逻辑表达式）或布尔变量。

执行流程：

首先判断条件表达式看其结果是true还是false
如果是true就执行语句块
如果是false就不执行语句块

b）双分支条件判断：if...else

格式：

if(条件表达式) {
语句块1;
}else {
语句块2;
}

执行流程：

1. 首先判断条件表达式看其结果是true还是false
2. 如果是true就执行语句块1
3. 如果是false就执行语句块2

c）多分支条件判断：if...else if...else

①格式：

if (条件表达式1) {
   语句块1;
} else if (条件表达式2) {
   语句块2;
}
...
}else if (条件表达式n) {
    语句块n;
} else {
   语句块n+1;
}

说明：一旦条件表达式为true，则进入执行相应的语句块。执行完对应的语句块之后，就跳出当前结构。

②执行流程：

1. 首先判断关系表达式1看其结果是true还是false
2. 如果是true就执行语句块1，然后结束当前多分支
3. 如果是false就继续判断关系表达式2看其结果是true还是false
4. 如果是true就执行语句块2，然后结束当前多分支
5. 如果是false就继续判断关系表达式…看其结果是true还是false
…
n. 如果没有任何关系表达式为true，就执行语句块n+1，然后结束当前多分支。

③案例

岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆跑车；
成绩为(80，99]时，奖励一辆山地自行车；
当成绩为[60,80]时，奖励环球影城一日游；
其它时，胖揍一顿。

说明：默认成绩是在[0,100]范围内

public class IfElseTest3 {
public static void main(String[] args) {

int score = 67;//岳小鹏的期末成绩
//写法一：默认成绩范围为[0,100]
if(score == 100){
System.out.println("奖励一辆跑车");
}else if(score > 80 && score <= 99){ //错误的写法：}else if(80 < score <= 99){
System.out.println("奖励一辆山地自行车");
}else if(score >= 60 && score <= 80){
System.out.println("奖励环球影城玩一日游");
}
//else{
// System.out.println("胖揍一顿");
//}

//写法二：
// 默认成绩范围为[0,100]
if(score == 100){
System.out.println("奖励一辆跑车");
}else if(score > 80){
System.out.println("奖励一辆山地自行车");
}else if(score >= 60){
System.out.println("奖励环球影城玩一日游");
}else{
System.out.println("胖揍一顿");
}
}
}

④需要注意的事：

当条件表达式之间是“`互斥`”关系时（即彼此没有交集），条件判断语句及执行语句间顺序无所谓。
当条件表达式之间是“`包含`”关系时，“`小上大下 / 子上父下`”，否则范围小的条件表达式将不可能被执行。

d）if...else嵌套

在 if 的语句块中，或者是在else语句块中，又包含了另外一个条件判断（可以是单分支、双分支、多分支），就构成了嵌套结构。

①执行的特点：

（1）如果是嵌套在if语句块中的，只有当外部的if条件满足，才会去判断内部的条件
（2）如果是嵌套在else语句块中的，只有当外部的if条件不满足，进入else后，才会去判断内部的条件

②案例：

由键盘输入三个整数分别存入变量num1、num2、num3，对它们进行排序(使用 if-else if-else)，并且从小到大输出。

class IfElseTest4 {
   public static void main(String[] args) {

           //声明num1,num2,num3三个变量并赋值
           int num1 = 23,num2 = 32,num3 = 12;

           if(num1 >= num2){

               if(num3 >= num1)
                   System.out.println(num2 + "-" + num1 + "-" + num3);
               else if(num3 <= num2)
                   System.out.println(num3 + "-" + num2 + "-" + num1);
               else
                   System.out.println(num2 + "-" + num3 + "-" + num1);
           }else{ //num1 < num2

               if(num3 >= num2){
                   System.out.println(num1 + "-" + num2 + "-" + num3);
               }else if(num3 <= num1){
                   System.out.println(num3 + "-" + num1 + "-" + num2);
               }else{
                   System.out.println(num1 + "-" + num3 + "-" + num2);
               }
           }
   }
}

其他说明：

语句块只有一条执行语句时，一对{}可以省略，但建议保留。
当if-else结构是“多选一”时，最后的else是可选的，根据需要可以省略。

2.switch-case选择结构

a）语法格式

switch(表达式){
case 常量值1:
语句块1;
//break;
case 常量值2:
语句块2;
//break;
// ...
[default:
语句块n+1;
break;
]
}

b）执行过程

第1步：根据switch中表达式的值，依次匹配各个case。如果表达式的值等于某个case中的常量值，则执行对应case中的执行语句。
第2步：执行完此case的执行语句以后，

情况1：如果遇到break,则执行break并跳出当前的switch-case结构
情况2：如果没有遇到break，则会继续执行当前case之后的其它case中的执行语句，直到遇到break关键字或执行完所有的case及default的执行语句，跳出当前的switch-case结构。（case穿透）

c）使用注意点

switch(表达式)中表达式的值必须是下述几种类型之一：byte，short，char，int，枚举 (jdk 5.0)，String (jdk 7.0)；
case子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；
同一个switch语句，所有case子句中的常量值互不相同；
break语句用来在执行完一个case分支后使程序跳出switch语句块；
如果没有break，程序会顺序执行到switch结尾；
default子句是可选的。同时，位置也是灵活的。当没有匹配的case时，执行default语句。

d）举例

public class SwitchCaseTest2 {
public static void main(String args[]) {
String season = "summer";
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;
}
}
}

e）利用case的穿透性

在switch语句中，如果case的后面不写break，将出现穿透现象，也就是一旦匹配成功，不会在判断下一个case的值，直接向后运行，直到遇到break或者运行完整个switch语句结束，执行终止。

案例1：编写程序：从键盘上输入2023年的“month”和“day”，要求通过程序输出输入的日期为2023年的第几天。

import java.util.Scanner;

class SwitchCaseTest4 {
   public static void main(String[] args) {

       Scanner scan = new Scanner(System.in);

System.out.println("请输入2023年的month:");
int month = scan.nextInt();

System.out.println("请输入2023年的day:");
int day = scan.nextInt();

//这里就不针对month和day进行合法性的判断了，以后可以使用正则表达式进行校验。

       int sumDays = 0;//记录总天数

       //写法1 ：不推荐（存在冗余的数据）
       /*
       switch(month){
           case 1:
               sumDays = day;
               break;
           case 2:
               sumDays = 31 + day;
               break;
           case 3:
               sumDays = 31 + 28 + day;
               break;
           //....

           case 12:
               //sumDays = 31 + 28 + ... + 30 + day;
               break;
       }
       */

       //写法2：推荐
       switch(month){
           case 12:
               sumDays += 30;//这个30是代表11月份的满月天数
           case 11:
               sumDays += 31;//这个31是代表10月份的满月天数
           case 10:
               sumDays += 30;//这个30是代表9月份的满月天数
           case 9:
               sumDays += 31;//这个31是代表8月份的满月天数
           case 8:
               sumDays += 31;//这个31是代表7月份的满月天数
           case 7:
               sumDays += 30;//这个30是代表6月份的满月天数
           case 6:
               sumDays += 31;//这个31是代表5月份的满月天数
           case 5:
               sumDays += 30;//这个30是代表4月份的满月天数
           case 4:
               sumDays += 31;//这个31是代表3月份的满月天数
           case 3:
               sumDays += 28;//这个28是代表2月份的满月天数
           case 2:
               sumDays += 31;//这个31是代表1月份的满月天数
           case 1:
               sumDays += day;//这个day是代表当月的第几天
       }

       System.out.println(month + "月" + day + "日是2023年的第" + sumDays + "天");
//关闭资源
       scan.close();//为了防止内存的泄漏，即使这行语句不写，也不会编译报错。由于垃圾回收机制不会回收这类与用户交互的资源，所以这类资源不会认为是垃圾，从而造成内存泄漏。
   }
}

案例2：

从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或
2）可以被400整除
例如：1900，2200等能被4整除，但同时能被100整除，但不能被400整除，不是闰年

import java.util.Scanner;

public class SwitchCaseTest04 {

public static void main(String[] args) {

Scanner scanner = new Scanner(System.in);
System.out.print("请输入year:");
int year = scanner.nextInt();

System.out.print("请输入month:");
int month = scanner.nextInt();

System.out.print("请输入day:");
int day = scanner.nextInt();

//判断这一天是当年的第几天==>从1月1日开始，累加到xx月xx日这一天
//(1)[1,month-1]个月满月天数
//(2)单独考虑2月份是否是29天（依据是看year是否是闰年）
//(3)第month个月的day天

//声明一个变量days，用来存储总天数
int sumDays = 0;

//累加[1,month-1]个月满月天数
switch (month) {
case 12:
//累加的1-11月
sumDays += 30;//这个30是代表11月份的满月天数
//这里没有break，继续往下走
case 11:
//累加的1-10月
sumDays += 31;//这个31是代表10月的满月天数
//这里没有break，继续往下走
case 10:
sumDays += 30;//9月
case 9:
sumDays += 31;//8月
case 8:
sumDays += 31;//7月
case 7:
sumDays += 30;//6月
case 6:
sumDays += 31;//5月
case 5:
sumDays += 30;//4月
case 4:
sumDays += 31;//3月
case 3:
sumDays += 28;//2月
//在这里考虑是否可能是29天
if (year % 4 == 0 && year % 100 != 0 || year % 400 == 0) {
sumDays++;//多加1天
}
case 2:
sumDays += 31;//1月
case 1:
sumDays += day;//第month月的day天
}

//输出结果
System.out.println(year + "年" + month + "月" + day + "日是这一年的第" + sumDays + "天");

scanner.close();
}
}

案例3:押宝游戏

随机产生3个1-6的整数，如果三个数相等，那么称为“豹子”，如果三个数之和大于9，称为“大”，如果三个数之和小于等于9，称为“小”，用户从键盘输入押的是“豹子”、“大”、“小”，并判断是否猜对了

提示：随机数 Math.random()产生 [0,1)范围内的小数
如何获取[a,b]范围内的随机整数呢？(int)(Math.random() * (b - a + 1)) + a

import java.util.Scanner;

public class SwitchCaseExer5 {
public static void main(String[] args) {
//1、随机产生3个1-6的整数
int a = (int)(Math.random()*6 + 1);
int b = (int)(Math.random()*6 + 1);
int c = (int)(Math.random()*6 + 1);

//2、押宝
Scanner input = new Scanner(System.in);
System.out.print("请押宝（豹子、大、小）：");
String ya = input.next();
input.close();

//3、判断结果
boolean result = false;
//switch支持String类型
switch (ya){
case "豹子": result = a == b && b == c; break;
case "大": result = a + b + c > 9; break;
case "小": result = a + b + c <= 9; break;
default:System.out.println("输入有误！");
}

System.out.println("a,b,c分别是：" + a +"," + b +"," + c );
System.out.println(result ? "猜中了" : "猜错了");
}
}

f）if-else语句与switch-case语句比较

结论：凡是使用switch-case的结构都可以转换为if-else结构。反之，不成立。
开发经验：如果既可以使用switch-case，又可以使用if-else，建议使用switch-case。因为效率稍高。
细节对比：
- if-else语句优势
  - if语句的条件是一个布尔类型值，if条件表达式为true则进入分支，可以用于范围的判断，也可以用于等值的判断，使用范围更广。
  - switch语句的条件是一个常量值（byte,short,int,char,枚举,String），只能判断某个变量或表达式的结果是否等于某个常量值，使用场景较狭窄。
- switch语句优势
  - 当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用if和switch都可以，习惯上使用switch更多。因为效率稍高。当条件是区间范围的判断时，只能使用if语句。
  - 使用switch可以利用穿透性，同时执行多个分支，而if...else没有穿透性。

四、循环结构

1.循环结构的介绍

理解：循环语句具有在`某些条件`满足的情况下，`反复执行`特定代码的功能。
循环结构分类：
- for 循环
- while 循环
- do-while 循环
循环结构`四要素`：
- 初始化部分
- 循环条件部分
- 循环体部分
- 迭代部分

2.for循环

a）语法格式

for (①初始化部分; ②循环条件部分; ④迭代部分)｛
③循环体部分;
｝

b）执行过程

①-②-③-④-②-③-④-②-③-④-.....-②

c）执行过程图示

d）说明

for(;;)中的两个；不能多也不能少
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
②循环条件部分为boolean类型表达式，当值为false时，退出循环
④可以有多个变量更新，用逗号分隔

e）案例

案例一：编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”

public class ForExer3 {

public static void main(String[] args) {

//方法一：不推荐

        boolean threeResult,fiveResult,sevenResult;
       for(int i=1;i<=150;i++){
           threeResult = (i%3==0);
           fiveResult = (i%5==0);
           sevenResult = (i%7==0);
           if(threeResult & fiveResult & sevenResult ){
               System.out.println(i + " foo biz baz");
           }else if(threeResult & fiveResult){
               System.out.println(i + " foo biz");
           }else if(threeResult & sevenResult){
               System.out.println(i + " foo baz");
           }else if(fiveResult & sevenResult ){
               System.out.println(i + " biz baz");
           }else if(threeResult){
               System.out.println(i + " foo");
           }else if(fiveResult){
               System.out.println(i + " biz");
           }else if(sevenResult){
               System.out.println(i + " baz");
           }else{

System.out.println(i);

}
}

//方法二：推荐

for (int i = 1; i < 150; i++) {
System.out.print(i + "\t");
if(i % 3 == 0){
System.out.print("foo\t");
}
if(i % 5 == 0){
System.out.print("biz\t");
}
if(i % 7 == 0){
System.out.print("baz\t");
}

System.out.println();
}
}
}

案例二（结合break的使用）：输入两个正整数m和n，求其最大公约数和最小公倍数。

public class ForTest5 {
public static void main(String[] args) {
//需求1：最大公约数
int m = 12, n = 20;
//取出两个数中的较小值
int min = (m < n) ? m : n;

for (int i = min; i >= 1; i--) {//for(int i = 1;i <= min;i++){

if (m % i == 0 && n % i == 0) {
System.out.println("最大公约数是：" + i); //公约数

break; //跳出当前循环结构
}
}

//需求2：最小公倍数
//取出两个数中的较大值
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;
}
}

}
}

注意说明：

我们可以在循环中使用break。一旦执行break，就跳出当前循环结构。
小结：如何结束一个循环结构？
- 结束情况1：循环结构中的循环条件部分返回false
- 结束情况2：循环结构中执行了break。
如果一个循环结构不能结束，那就是一个死循环！我们开发中要避免出现死循环。

3.while循环

a）语法格式

①初始化部分
while(②循环条件部分)｛
③循环体部分;
④迭代部分;
}

b）执行过程

①-②-③-④-②-③-④-②-③-④-...-②

c）执行过程图示

d）说明

while(循环条件)中循环条件必须是boolean类型。
注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
for循环和while循环可以相互转换。二者没有性能上的差别。实际开发中，根据具体结构的情况，选择哪个格式更合适、美观。
for循环与while循环的区别：初始化条件部分的作用域不同。

e）案例

案例一：猜数字游戏

随机生成一个100以内的数，猜这个随机数是多少？
从键盘输入数，如果大了，提示大了；如果小了，提示小了；如果对了，就不再猜了，并统计一共猜了多少次。
提示：生成一个[a,b] 范围的随机数的方式：(int)(Math.random() * (b - a + 1) + a)

public class GuessNumber {
public static void main(String[] args) {
//获取一个随机数
int random = (int) (Math.random() * 100) + 1;

//记录猜的次数
int count = 1;

//实例化Scanner
Scanner scan = new Scanner(System.in);
System.out.println("请输入一个整数(1-100):");
int guess = scan.nextInt();

while (guess != random) {

if (guess > random) {
System.out.println("猜大了");
} else if (guess < random) {
System.out.println("猜小了");
}

System.out.println("请输入一个整数(1-100):");
guess = scan.nextInt();
//累加猜的次数
count++;

}

System.out.println("猜中了！");
System.out.println("一共猜了" + count + "次");
}
}

案例二：折纸珠穆朗玛峰

世界最高山峰是珠穆朗玛峰，它的高度是8848.86米，假如我有一张足够大的纸，它的厚度是0.1毫米。
请问，我折叠多少次，可以折成珠穆朗玛峰的高度?

public class ZFTest {
public static void main(String[] args) {
//定义一个计数器，初始值为0
int count = 0;

//定义珠穆朗玛峰的高度
int zf = 8848860;//单位：毫米

double paper = 0.1;//单位：毫米

while(paper < zf){
//在循环中执行累加，对应折叠了多少次
count++;
paper *= 2;//循环的执行过程中每次纸张折叠，纸张的厚度要加倍
}

//打印计数器的值
System.out.println("需要折叠：" + count + "次");
System.out.println("折纸的高度为" + paper/1000 + "米，超过了珠峰的高度");
}
}

4.do...while循环

a）语法格式

①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分);

b）执行过程

①-③-④-②-③-④-②-③-④-...-②

c）执行过程图示

d）说明

结尾while(循环条件)中循环条件必须是boolean类型。
do{}while();最后有一个分号。
do-while结构的循环体语句是至少会执行一次，这个和for和while是不一样的。
循环的三个结构for、while、do-while三者是可以相互转换的。

e）案例

案例一：体会do-while至少会执行一次循环体

class DoWhileTest2 {
   public static void main(String[] args) {
//while循环:
       int num1 = 10;
       while(num1 > 10){
           System.out.println("hello:while");
           num1--;
       }

       //do-while循环:
       int num2 = 10;
       do{
           System.out.println("hello:do-while");
           num2--;
       }while(num2 > 10);

}
}

案例二：ATM取款

声明变量balance并初始化为0，用以表示银行账户的余额，下面通过ATM机程序实现存款，取款等功能。

=========ATM========
1、存款
2、取款
3、显示余额
4、退出
请选择(1-4)：

import java.util.Scanner;

public class ATM {
public static void main(String[] args) {

       //初始化条件
       double balance = 0.0;//表示银行账户的余额
       Scanner scan = new Scanner(System.in);
       boolean isFlag = true;//用于控制循环的结束

       do{
           System.out.println("=========ATM========");
           System.out.println("\t1、存款");
           System.out.println("\t2、取款");
           System.out.println("\t3、显示余额");
           System.out.println("\t4、退出");
           System.out.print("请选择(1-4)：");

           int selection = scan.nextInt();

           switch(selection){
               case 1:
                   System.out.print("要存款的额度为：");
                   double addMoney = scan.nextDouble();
                   if(addMoney > 0){
                       balance += addMoney;
                   }
                   break;
               case 2:
                   System.out.print("要取款的额度为：");
                   double minusMoney = scan.nextDouble();
                   if(minusMoney > 0 && balance >= minusMoney){
                       balance -= minusMoney;
                   }else{
                       System.out.println("您输入的数据非法或余额不足");
                   }
                   break;
               case 3:
                   System.out.println("当前的余额为：" + balance);
                   break;
               case 4:
                   System.out.println("欢迎下次进入此系统。^_^");
                   isFlag = false;
                   break;
               default:
                   System.out.println("请重新选择！");
                   break;
           }

       }while(isFlag);

       //资源关闭
       scan.close();

   }
}

5.对比三种循环结构

三种循环结构都具有四个要素：
- 循环变量的初始化条件
- 循环条件
- 循环体语句块
- 循环变量的修改的迭代表达式
从循环次数角度分析
- do-while循环至少执行一次循环体语句。
- for和while循环先判断循环条件语句是否成立，然后决定是否执行循环体。
如何选择
- 遍历有明显的循环次数（范围）的需求，选择for循环
- 遍历没有明显的循环次数（范围）的需求，选择while循环
- 如果循环体语句块至少执行一次，可以考虑使用do-while循环
- 本质上：三种循环之间完全可以互相转换，都能实现循环的功能

6.无限循环

a）图示解释无限循环

b）基本语法

语法格式：
- 最简单"无限"循环格式：while(true) , for(;;)
适用场景
- 开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。
- 如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环。

c）案例

/*从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。*/

import java.util.Scanner;

class PositiveNegative {
   public static void main(String[] args) {
       Scanner scanner = new Scanner(System.in);

       int positiveNumber = 0;//统计正数的个数
       int negativeNumber = 0;//统计负数的个数
       for(;;){ //while(true){
           System.out.println("请输入一个整数：(输入为0时结束程序)");
           int num = scanner.nextInt();
           if(num > 0){
               positiveNumber++;
}else if(num < 0){
               negativeNumber++;
   }else{
System.out.println("程序结束");
               break;
}
}
       System.out.println("正数的个数为："+ positiveNumber);
       System.out.println("负数的个数为："+ negativeNumber);

scanner.close();
   }
}

d) 循环的几种特殊形式

循环有特殊形式，即循环结构四要素缺失所引起。并且四要素可以任意缺失其中一个或多个，但是需要注意的是要保留这个要素的存在位置。解释如下：

/*案例：实现爱你到永远*/

public class EndlessFor1 {
public static void main(String[] args) {

//缺失初始化部分、循环条件、迭代部分。但保留其位置。引起无限循环
for (;;){
System.out.println("我爱你！");
}
// System.out.println("end");//永远无法到达的语句，编译报错

//缺失：初始化部分、迭代部分，并且判断条件始终为true。但保留其位置，引起无限循环。

for (; true;){ //条件永远成立，死循环
System.out.println("我爱你！");
}

//缺失：迭代部分，并且判断条件始终为true。但保留其位置，引起无限循环。

for (int i=1; i<=10; ){ //循环变量没有修改，条件永远成立，死循环
System.out.println("我爱你！");
}
}
}

7.嵌套循环

a）使用说明

所谓嵌套循环，是指一个循环结构A的循环体是另一个循环结构B。比如，for循环里面还有一个for循环，就是嵌套循环。其中，for ,while ,do-while均可以作为外层循环或内层循环。
- 外层循环：循环结构A
- 内层循环：循环结构B
实质上，嵌套循环就是把内层循环当成外层循环的循环体。只有当内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的外层循环。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
技巧：从二维图形的角度看，外层循环控制行数，内层循环控制列数。
开发经验：实际开发中，我们最多见到的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果将要出现，一定要停下来重新梳理业务逻辑，重新思考算法的实现，控制在三层以内。否则，可读性会很差。

例如：两个for嵌套循环格式

for(初始化语句①; 循环条件语句②; 迭代语句⑦) {
for(初始化语句③; 循环条件语句④; 迭代语句⑥) {
循环体语句⑤;
}
}

//执行过程：① - ② - ③ - ④ - ⑤ - ⑥ - ④ - ⑤ - ⑥ - ... - ④ - ⑦ - ② - ③ - ④ - ⑤ - ⑥ - ④..

//执行特点：内层循环充当了外层循环的循环体。即：外层循环执行一次，内层循环执行一轮。

b）案例

案例一：打印5行6个*

class ForForTest1 {
   public static void main(String[] args) {
       /*

       ******
       ******
       ******
       ******
       ******

       */

       for(int j = 1;j <= 5;j++){

           for(int i = 1;i <= 6;i++){
               System.out.print("*");
           }

           System.out.println();
       }
}
}

案例二：打印5行直角三角形

/*
        *
        **
        ***
        ****
        *****
*/

public class ForForTest2 {
public static void main(String[] args){
for (int i = 1; i <= 5; i++) {
for (int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
}
}

案例三：打印5行倒直角三角形

*****
****
***
**
*

public class ForForTest3 {
public static void main(String[] args){
for(int i = 1;i <= 5;i++){
           for(int j = 1;j <= 6 - i;j++){
               System.out.print("*");

           }
           System.out.println();

       }
}
}

案例四：打印“菱形”形状的图案

*
* * *
* * * * *
* * * * * * *
* * * * * * * * *
* * * * * * *
* * * * *
* * *
*

public class ForForTest4 {

public static void main(String[] args) {
/*
上半部分       i       m(表示-的个数) n(表示*的个数)关系式：2*i + m = 10 --> m = 10 - 2*i
--------*       1   8           1                           n = 2 * i - 1
------* * *       2   6           3
----* * * * *   3   4           5
--* * * * * * *   4   2       7
* * * * * * * * * 5   0           9

下半部分 i m n 关系式： m = 2 * i
--* * * * * * * 1 2 7 n = 9 - 2 * i
----* * * * * 2 4 5
------* * * 3 6 3
--------* 4 8 1

*/
//上半部分
for (int i = 1; i <= 5; i++) {
//-
for (int j = 1; j <= 10 - 2 * i; j++) {
System.out.print(" ");
}
//*
for (int k = 1; k <= 2 * i - 1; k++) {
System.out.print("* ");
}
System.out.println();
}
//下半部分
for (int i = 1; i <= 4; i++) {
//-
for (int j = 1; j <= 2 * i; j++) {
System.out.print(" ");
}

//*
for (int k = 1; k <= 9 - 2 * i; k++) {
System.out.print("* ");
}
System.out.println();
}
}

}

案例5：九九乘法表

public class ForForTest5 {
public static void main(String[] args) {
for (int i = 1; i <= 9; i++) {
for (int j = 1; j <= i; j++) {
System.out.print(i + "*" + j + "=" + (i * j) + "\t");
}
System.out.println();
}
}
}

8.关键字break和continue的使用

适用范围

在循环结构的作用

相同点

break

switch-case

循环结构

一旦执行，就结束（或跳出）当前循环结构

此关键字的后面不能声明语句

continue

循环结构

一旦执行，就结束（或跳出）当次循环结构

此关键字的后面不能声明语句

说明：此外，很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它，但使程序容易出错。Java中的break和continue是不同于goto的。

a）举例

class BreakContinueTest1 {
   public static void main(String[] args) {

       for(int i = 1;i <= 10;i++){

           if(i % 4 == 0){
               //break;//123
               continue;//123567910
               //如下的语句不可能被执行，编译不通过
               //System.out.println("今晚迪丽热巴要约我吃饭");
           }

System.out.print(i);
}

System.out.println("####");

       //嵌套循环中的使用
       for(int i = 1;i <= 4;i++){

           for(int j = 1;j <= 10;j++){
               if(j % 4 == 0){
                   //break; //结束的是包裹break关键字的最近的一层循环！
                   continue;//结束的是包裹break关键字的最近的一层循环的当次！
               }
               System.out.print(j);
           }
           System.out.println();
       }

}
}

b）标签label的使用

break语句用于终止某个语句块的执行
{ ……
   break;
   ……
}

break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
   label1: { ……
   label2:   { ……
   label3:           { ……
               break label2;
               ……
                   }
           }
           }

continue语句出现在多层嵌套的循环语句体中时，也可以通过标签指明要跳过的是哪一层循环。
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
举例：

class BreakContinueTest2 {
   public static void main(String[] args) {
       l:for(int i = 1;i <= 4;i++){

           for(int j = 1;j <= 10;j++){
               if(j % 4 == 0){
                   //break l;
                   continue l;
               }
               System.out.print(j);
           }
           System.out.println();
       }
   }
}

补充知识：如何获得一个随机数？

如何产生一个指定范围的随机整数？
1、Math类的random()的调用，会返回一个[0,1)范围的一个double型值
2、Math.random() * 100 ---> [0,100)
(int)(Math.random() * 100) ---> [0,99]
(int)(Math.random() * 100) + 5 ----> [5,104]
3、如何获取[a,b]范围内的随机整数呢？(int)(Math.random() * (b - a + 1)) + a

案例：

class MathRandomTest {
   public static void main(String[] args) {
       double value = Math.random();
       System.out.println(value);

       //[1,6]
       int number = (int)(Math.random() * 6) + 1; //
       System.out.println(number);
   }
}