一、程序流程控制

1.1 简单介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句

  1. 顺序控制
  2. 分支控制
  3. 循环控制

二、顺序控制

2.1 简单介绍

程序从上到下逐行的执行，中间没有任何判断和跳转

2.2 注意事项

Java中定义变量时采用合法的向前引用。如：
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式：
public class Test{
int num2 = num1 + 2;
int num1 = 12;
}

2.3 流程图演示

Java基础：程序控制结构 - 图1

三、分支控制 if - else

3.1 if - else 简单介绍

让程序有选择的执行。
有以下三种：

  1. 单分支
  2. 双分支
  3. 多分枝

3.2 单分支基本语法

if ( 条件表达式 ) {
执行代码块;（可以有多条语句）
}

说明：当条件表达式为 true 时，就会执行 { } 的代码。如果为 false ，就不执行。
特别说明，如果 { } 中只有一条语句，可以不用 { } ,建议写上 { }

3.3 单分支案例演示

If01.java

  1. /**
  2.  * title: If - else 单分支控制演示
  3.  */
  4. import java.util.Scanner;
  5. public class If01 {
  7.     public static void main(String[] args) {
  8.         Scanner scan = new Scanner(System.in); 
  9.         // 可以输入年龄，如果大于18岁，则输出“已成年”
  10.         System.out.println("请输入年龄");
  11.         int age = scan.nextInt();
  12.         if (age >= 18) {
  13.             System.out.println("已成年");
  14.         }
  15.     }
  16. }

3.4 If - else 单分支流程图

Java基础：程序控制结构 - 图2

3.5 双分支基本语法

if ( 条件表达式 ) {
执行代码块1;
}
else {
执行代码块2;
}

说明：当条件表达式成立，执行代码块1，否则执行代码块2。如果执行代码块 只有一条语句，则 { } 可以省略，否则不能省略。

3.6 双分支案例演示

If02.java

  1. /**
  2.  * title: if - else 双分支控制演示
  3.  */
  4. import java.util.Scanner;
  5. public class If02 {
  7.     public static void main(String[] args) {
  8.         Scanner myScanner = new Scanner(System.in);
  9.         System.out.println("请输入年龄：");
  10.         int age = myScanner.nextInt();
  11.         if (age > 18) {
  12.             System.out.println("你年龄大于18，要对自己的行为负责，送入监狱");
  13.         } else {
  14.             System.out.println("你年龄不大，这次放过你了");
  15.         }
  16.     }
  17. }

3.7 双分支流程图

Java基础：程序控制结构 - 图3

3.8 多分支基本语法

if ( 条件表达式1 ) {
执行代码块1;
}
else if ( 条件表达式2 ) {
执行代码块2;
}
……
else {
执行代码块n;
}

特别说明：

  1. 多分支可以没有最后的 else ( ) ，如果所有条件表达式都不成立，则所有执行代码块都不执行。
  2. 如果有最后的 else ( ) ，如果所有条件表达式都不成立，则默认执行 else ( ) 里的代码块。

3.9 多分支案例演示

  1. /**
  2.  * title:if多分支演示
  3.  */
  4. import java.util.Scanner;
  5. public class If03 {
  7.     public static void main(String[] args) {
  8.         Scanner myScanner = new Scanner(System.in);
  9.         System.out.println("请输入芝麻信用分");
  10.         int score = myScanner.nextInt();
  11.         if (score == 100) {
  12.             System.out.println("信用极好");
  13.         } else if (80 < score && score < 100 ) {
  14.             System.out.println("信用优秀");
  15.         } else if (60 <= score && score <= 80 ) {
  16.             System.out.println("信用一般");
  17.         } else {
  18.             System.out.println("信用不及格");
  19.         }
  21.     }
  22. }

3.10 多分支流程图

Java基础：程序控制结构 - 图4

说明：

  1. 当条件表达式1成立时，即执行代码块1
  2. 如果表达式1不成立，才回去判断表达式2是否成立
  3. 当条件表达式2成立，即执行代码块2
  4. 以此类推，如果所有的表达式都不成立
  5. 则执行 else 里的代码块，注意，只能有一个执行入口

3.11 嵌套分支基本介绍

在一个分支结构中又完整的嵌套了另一个完整的结构，里面的分支的结构成为内层分支外面的分支结构成为外层分支。规范：不要超过3层（可读性不好）

基本语法：
if ( ) {
if ( ) {
// if - else…
} else {
// if - else
}
}

3.12 嵌套分支案例演示

NestedIf.java

  1. /**
  2.  * title: 嵌套分支案例演示
  3.  */
  4. import java.util.Scanner;
  5. public class NestedIf {
  7.     public static void main(String[] args) {
  8.         /* 要求：参加歌手比赛，如果初赛成绩大于8.0进入决赛，
  9.         否则提示淘汰。并且根据性别提示进入男子组或女子组。
  10.         输入成绩和性别，进行判断和输出信息。 */
  12.         // 思路分析
  13.         // 1.创建Scanner对象，用于接收用户输入
  14.         // 2.使用嵌套分支，第一层判断成绩，第二层判断性别
  15.         Scanner myScanner = new Scanner(System.in);
  16.         //主功能实现
  17.         System.out.println("请输入初赛成绩：");
  18.         double score = myScanner.nextDouble();
  19.         if (score > 8.0) {
  20.             System.out.println("请输入性别(男/女)：");
  21.             char gender = myScanner.next().charAt(0);
  22.             if (gender == '男') {
  23.                 System.out.println("恭喜进入决赛，已被分到男子组");
  24.             } else if (gender == '女') {
  25.                 System.out.println("恭喜进入决赛，已被分到女子组");
  26.             } else {
  27.                 System.out.println("你的性别有误，不能参加决赛");
  28.             }
  29.         } else {
  30.             System.out.println("可惜，你被淘汰了~");
  31.         }
  32.     }
  33. }

⏱ 小练习
设计一个出票系统：根据淡旺季的月份和年龄，打印票价 【NestedIfExe.java】
4-10月 旺季：
成人（18-60岁）：60
儿童（<18）：半价
老人（>60）：1/3
淡季：
成人：40
其他：20

四、switch 分支结构

4.1 基本语法

switch (表达式) {
case 常量1: //当…..
语句块1;
break;
case 常量2:
语句块2;
break;
…
case 常量n:
语句块n;
break;
default:
default语句块;
break;
}

4.2 语法说明

  1. switch 关键字，表示 switch 分支
  2. 表达式 对应一个值
  3. case 常量1：当表达式的值等于常量1，就执行 语句块1
  4. break：表示推出 switch
  5. 如果 case 常量1 匹配，就执行语句块1，如果没有匹配，就继续尝试匹配 case 常量2
  6. 以此类推，如果都没有匹配上，执行 default

4.3 switch 流程图

Java基础：程序控制结构 - 图5

4.4 案例演示

Switch01.java

  1. /**
  2.  * title: Switch 演示
  3.  */
  4. import java.util.Scanner;
  5. public class Switch01 {
  6.     // 编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f,g
  7.     // a 表示星期一，b表示星期二....
  8.     // 根据用户的输入显示相应的信息，要求使用 switch 语句完成
  9.     public static void main(String[] args) {
  10.         Scanner input = new Scanner(System.in);
  11.         System.out.println("请输入一个字符(a-g)");
  12.         char week = input.next().charAt(0);
  13.         switch (week) {
  14.             case 'a':
  15.                 System.out.println("星期一");
  16.                 break;
  17.             case 'b':
  18.                 System.out.println("星期二");
  19.                 break;
  20.             case 'c':
  21.                 System.out.println("星期三");
  22.                 break;
  23.             case 'd':
  24.                 System.out.println("星期四");
  25.                 break;
  26.             case 'e':
  27.                 System.out.println("星期五");
  28.                 break;
  29.             case 'f':
  30.                 System.out.println("星期六");
  31.                 break;
  32.             case 'g':
  33.                 System.out.println("星期日");
  34.                 break;
  35.             default:
  36.                 System.out.println("没有正确输入a-g");
  37.                 break;  // 此处可省略
  38.         }
  39.     }
  41. }

4.5 switch 使用细节

  1. 表达式数据类型，应和 case 后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是 int
  2. switch（表达式）中表达式的返回值必须是：(byte，short，int，char，enum，String)
  3. case 子句中的值必须是常量，而不能是变量
  4. default 子句是可选的，当没有匹配的 case 时，执行 default
  5. break 语句用来在执行完一个 case 分支后使程序 跳出 switch 语句块；如果没有写 break ，程序会顺序执行到 switch 结尾，除非遇到一个break。

⏱ 小练习

  1. 使用 switch 把小写类型的 char 型转为大写（键盘输入）。只转换 a,b,c,d,e，其他的输出 “other”
  2. 对学生成绩大于60分的，输出”合格”，低于60分的，输出”不合格”。
    （注：输入的成绩不能大于100 提示：成绩/60）
  3. 根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12,1,2 冬季【提示：使用穿透】

SwitchExercise.java

  1. import java.util.Scanner;
  2. public class SwitchExercise {
  4.     public static void main(String[] args) {
  5.         Scanner inp = new Scanner(System.in);
  7.         System.out.println("请输入单个小写字母");
  8.         char word = inp.next().charAt(0);
  9.         switch (word) {
  10.             case 'a':
  11.                 System.out.println("A");
  12.                 break;
  13.             case 'b':
  14.                 System.out.println("B");
  15.                 break;
  16.             case 'c':
  17.                 System.out.println("C");
  18.                 break;
  19.             case 'd':
  20.                 System.out.println("D");
  21.                 break;
  22.             case 'e':
  23.                 System.out.println("E");
  24.                 break;
  25.             default:
  26.                 System.out.println("other");
  27.                 break;
  28.         }
  31.         System.out.println("请输入学生成绩");
  32.         double score = inp.nextDouble();
  33.         if (score <= 100 && score >=0) {
  34.             switch ((int)(score / 60)) {
  35.                 case 0:
  36.                     System.out.println("不合格");
  37.                     break;
  38.                 case 1:
  39.                     System.out.println("合格");
  40.                     break;
  41.             }
  42.         } else {
  43.             System.out.println("成绩不能大于100");
  44.         }
  47.         System.out.println("请输入月份（1-12）");
  48.         int month = inp.nextInt();
  49.         switch (month) {
  50.             case 12:
  51.             case 1:
  52.             case 2:
  53.                 System.out.println("冬季");
  54.                 break;
  55.             case 3:
  56.             case 4:
  57.             case 5:
  58.                 System.out.println("春季");
  59.                 break;
  60.             case 6:
  61.             case 7:
  62.             case 8:
  63.                 System.out.println("夏季");
  64.                 break;
  65.             case 9:
  66.             case 10:
  67.             case 11:
  68.                 System.out.println("秋季");
  69.                 break;
  70.             default:
  71.                 System.out.println("输入的月份有误");
  72.         }
  74.     }
  75. }

4.6 switch 和 if 的比较

  1. 如果判断的具体数值不多，而且符合byte、short、int、char、enum、String 这六种类型，虽然两种都可以使用，建议使用 switch
  2. 其他情况：对区间判断，对结果为 boolean 类型判断，使用 if 范围更广

五、for 循环控制

5.1 基本语法

for ( 循环变量初始化; 循环条件; 循环变量迭代 ) {
循环操作（语句）;
}

5.2 简单说明

  1. for 关键字，表示循环控制
  2. for 有四要素：
    1. 循环变量初始化
    2. 循环条件
    3. 循环操作
    4. 循环变量迭代
  3. 循环操作，这里可以有多条语句，也就是我们要循环执行的代码
  4. 如果 循环操作（语句）只有一条语句，可以省略 { } ,建议不省略

5.3 for 循环流程图

Java基础：程序控制结构 - 图6

5.4 for 循环 注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. for( ;循环判断条件; )中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略
  3. 循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，
    循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开
  4. 使用内存分析法，分析下面代码输出什么？
    int count = 3;
    for (int i = 0,j = 0; i < count; i++, j +=2) {
    System.out.println(“i=” + i + “j=” + j);
    }

ForDetail.java

  1. public class ForDetail {
  3.     public static void main(String[] args) {
  4.         int j = 1;
  5.         //for( ;循环判断条件; )
  6.         //中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略
  7.         for (;j <= 10 ; ) {
  8.             System.out.println("hello,We learn Java~");
  9.             j++;
  10.         }
  11.         System.out.println("j=" + j);
  13.         //补充
  14.         for (; ; ) {  //表示无限循环，死循环
  15.             System.out.println("无限循环");
  16.         }
  17.     }
  18. }

⏱ 小练习

  1. 打印1~100之间所有是9的倍数的整数，统计个数 及 总和。
  2. 完成下面的表达式输出
    image.png

ForExercise.java

  1. public class ForExercise {
  3.     public static void main(String[] args) {
  4.         // 打印1~100之间所有是9的倍数的整数，统计个数 及 总和
  5.         int i = 1;
  6.         int j = 0;
  7.         int sum = 0;
  8.         for (i = 1;i <= 100 ;i++ ) {
  9.             if (i % 9 == 0) {
  10.                 j++;
  11.                 sum += i;
  12.             }
  13.         }
  14.         System.out.println("1-100中9的倍数的整数个数为：" 
  15.             + j + "，总和为：" + sum);
  17.         // 完成下面的表达式输出
  18.         for (int a = 0,b = 5;a < 6 ;a++,b-- ) {
  19.             System.out.println(a + " + " + b + " = " + (a + b) );
  20.         }
  21.     }
  22. }

两个编程思想（技巧）：

  1. 化繁为简：即将复杂的需求，拆解成简单的需求，逐步完成
  2. 先死后活：先考虑固定的值，然后转成可以灵活变化的值

六、while 循环控制

6.1 基本语法

循环变量初始化;
while ( 循环条件 ) {
循环体（语句）;
循环变量迭代;
}

6.2 语法说明

  1. while 循环也有四要素
  2. 四要素放的位置不一样

6.3 while 循环流程图

Java基础：程序控制结构 - 图8

6.4 while 循环注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. while 循环是先判断再执行语句

⏱ 小练习

  1. 打印1-100之间所有能被3整除的数【使用while】
  2. 打印40-200之间所有的偶数【使用while】

七、do-while 循环控制

7.1 基本语法

循环变量初始化;
do {
循环体（语句）;
循环变量迭代;
} while ( 循环条件 );

7.2 语法说明

  1. do-while 是关键字
  2. 也有循环四要素，只是位置不一样
  3. 先执行，再判断，也就是说，一定会至少执行一次
  4. 最后有一个分号

7.3 do-while 循环流程图

Java基础：程序控制结构 - 图9

7.4 do-while 循环注意事项和细节说明

  1. 循环条件是返回一个布尔值的表达式
  2. do…while循环是先执行，再判断，因此至少执行一次

⏱ 小练习

  1. 打印1-100
  2. 计算1-100的和
  3. 统计1-200 之间能被5整除但不能被3整除的个数
  4. 如果李三不还钱，则张三一直使出五连鞭，直到李三说还钱为止

DoWhileExercise.java

  1. import java.util.Scanner;
  2. public class DoWhileExercise {
  4.     public static void main(String[] args) {
  5.         // 老韩追债
  6.         Scanner myScanner = new Scanner(System.in);
  7.         char say;
  8.         do {
  9.             System.out.println("对老王使出五连鞭");
  10.             System.out.println("老韩问：还钱吗？ y/n");
  11.             say = myScanner.next().charAt(0);
  12.         } while(say != 'y');
  13.         System.out.println("老王还钱了");
  14.     }
  15. }

八、多重循环控制（难点！重点！）

8.1 简单介绍

  1. 将一个循环放在另一个循环内，就形成了嵌套循环。其中，for，while，do…while 均可作为外层循环和内层循环。【建议一般使用两层，最多不要超过三层，否则影响代码可读性】
  2. 实质上，嵌套循环就是由外向内 层层判断，再由内向外 层层执行的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，执行外层的下一次循环。
  3. 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

8.2 多重循环执行流程分析

Java基础：程序控制结构 - 图10
①：先执行外层循环第一步 i = 0 ，i < 2 成立 -> 接下来执行外层循环的循环体，也就是内层循环
②：内层循环第一步 j = 0，j < 3 成立 -> 执行内层循环的循环体，也就是打印语句，
输出 i=0 j=0 ->内层循环迭代 j++，得 j = 1
③：内层循环第二步 j = 1，j < 3 成立 -> 执行打印语句，输出 i=0 j=1 ->内层循环迭代 j++，得 j = 2
④：内层循环第三步 j = 2，j < 3 成立 -> 执行打印语句，输出 i=0 j=2 ->内层循环迭代 j++，得 j = 3
⑤：内层循环第四步 j = 3，j < 3 不成立 -> 结束内层循环，销毁 j 的内存 -> 回到外层循环
⑥：外层循环迭代 i++，得 i = 1
⑦：外层循环第二步 i = 1，i < 2 成立 -> 接下来执行外层循环的循环体，也就是内层循环
⑧：内层循环第一步 j = 0，j < 3 成立 -> 执行内层循环的循环体，也就是打印语句，输出 i=1 j=0 ->内层循环迭代 j++，得 j = 1
⑨：内层循环第二步 j = 1，j < 3 成立 -> 执行打印语句，输出 i=1 j=1 ->内层循环迭代 j++，得 j = 2
⑩：内层循环第三步 j = 2，j < 3 成立 -> 执行打印语句，输出 i=1 j=2 ->内层循环迭代 j++，得 j = 3
11：内层循环第四步 j = 3，j < 3 不成立 -> 结束内层循环，销毁 j 的内存 -> 回到外层循环
12：外层循环迭代 i++，得 i = 2
13：外层循环第三步 i = 2，i < 2 不成立 -> 结束外层循环，销毁 i 的内存

整理输出内容：
i=0 j=0
i=0 j=1
i=0 j=2
i=1 j=0
i=1 j=1
i=1 j=2

8.3 多重循环练习

应用实例：

  1. 统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分【学生的成绩从键盘输入】
  2. 统计3个班及格人数，每个班有5名同学
  3. 打印出九九乘法表

MulForExercise.java

  1. import java.util.Scanner;
  2. public class MulForExercise {
  4.     public static void main(String[] args) {
  6.         Scanner scan = new Scanner(System.in);
  8.         //统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所在班级的平均分
  9.         //统计3个班及格人数，每个班有5名同学
  11.         double score = 0.0;  // 用于记录成绩
  12.         double sum = 0.0;    // 用于记录当前班级总分
  13.         double meanSum = 0.0; // 用于记录所有班级平均分总和
  14.         int pass = 0;  // 用于记录及格人数
  16.         // 多重循环结构，外层记录班级，内层记录学生
  17.         for (int i = 1;i <= 3 ;i++ ) {  // 班级数
  18.             for (int j = 1;j <=5 ;j++ ) { // 学生数
  19.                 System.out.println("请输入" + i + "班" + j +"号同学的成绩：");
  20.                 score = scan.nextDouble();
  21.                 if (score >= 60.0) {
  22.                     pass++;
  23.                 }
  24.                 sum += score;
  25.             }
  26.             double mean = sum / 5;
  27.             System.out.println(i + "班的平均分为：" + mean);
  28.             meanSum += mean;
  29.             sum = 0.0;  // 归零用于记录下个班级的总分
  30.         }
  31.             double allMean = meanSum / 3;
  32.             System.out.println("所有班级的平均分为：" + allMean);
  33.             System.out.println("三个班总及格人数为" + pass);
  34.     }
  35. }

MulForExercise02.java

  1. public class MulForExercise02 {
  3.     public static void main(String[] args) {
  4.         // 打印出九九乘法表
  5.         for (int i = 1;i <= 9;i++ ) {
  6.             for (int j = 1;j <= i ;j++ ) {
  7.                 System.out.print(j + " × " + i + " = " + (i * j) + "\t");
  8.             }
  9.             System.out.println(" ");
  10.         }
  11.     }
  12. }

经典例题：打印金字塔
使用 for 循环完成下面的案例
请编写一个程序，可以接收一个整数，表示层数，打印出金字塔。（Stars.java）
image.png

笔者先独立完成的代码
初代：Pyramid01.java

  1. import java.util.Scanner;
  2. public class Pyramid01 {
  4.     public static void main(String[] args) {
  5.         Scanner scan = new Scanner(System.in);
  7.         System.out.println("请输入金字塔层数");
  8.         int totalLevel = scan.nextInt();   // 用于保存金字塔层数
  9.         // 嵌套循环，外层保证总层数(金字塔高度)，内层保证每一层 * 的数量(金字塔宽度)
  10.         for (int i = 1; i <= totalLevel ; i++  ) {
  11.             for (int j = 1;j <= i ;j++) {
  12.                 System.out.print("*");
  13.             }
  14.             System.out.println(" ");
  15.         }
  16.     }
  17. }

改进：Pyramid02.java

  1. import java.util.Scanner;
  2. public class Pyramid02 {
  4.     public static void main(String[] args) {
  5.         Scanner scan = new Scanner(System.in);
  7.         System.out.println("请输入金字塔层数");
  8.         int totalLevel = scan.nextInt();
  10.         for (int i = totalLevel; i >= 1; i--) {
  11.             for (int j = 1; j <= i; j++ ) {
  12.                 System.out.print(" ");  // 同一行输出
  13.             }
  14.             for (int k = 2 * i - 1; k <= 2 * totalLevel - 1;k++ ) {
  15.                 System.out.print("*");  // 同一行输出
  16.             }
  17.             System.out.println(" ");  // 换行
  18.         }
  19.     }
  20. }

最终：Pyramid03.java

  1. import java.util.Scanner;
  2. public class Pyramid03 {
  4.     public static void main(String[] args) {
  5.         Scanner scan = new Scanner(System.in);
  7.         System.out.println("请输入金字塔层数");
  8.         int totalLevel = scan.nextInt();
  10.         for (int i = totalLevel; i >= 1; i--) {
  11.             for (int j = 1; j <= i; j++) {
  12.                 System.out.print(" ");
  13.             }
  14.             for (int k = 2 * i - 1; k <= 2 * totalLevel - 1; k++) {
  15.                 if (i > 1) {  // 判断是否是最底层
  16.                     if (k == (2 * i - 1) | k == (2 * totalLevel - 1)) {
  17.                         System.out.print("*");  // 不是最底层，只在两头输出 * 号
  18.                     } else {
  19.                         System.out.print(" ");  // 中间用 空格 填充
  20.                     }
  21.                 } else {
  22.                     System.out.print("*");  // 最底层全部输出*号
  23.                 }    
  24.             }
  25.             System.out.println(" ");
  26.         }
  27.     }
  28. }

老师讲解的代码
Stars.java

  1. import java.util.Scanner;
  2. public class Stars {
  4.     public static void main(String[] args) {
  5.         Scanner myScanner = new Scanner(System.in);
  7.         // 思路分析
  8.         // 化繁为简
  9.         // 1.先打印一个矩形
  10.         // *****
  11.         // *****
  12.         // *****
  13.         // *****
  14.         for (int i = 1; i <= 5; i++) {
  15.             System.out.println("*****");
  16.         }
  18.         // 2.打印半个金字塔
  19.         // *       // 第1层 有 1个 *
  20.         // **      // 第2层 有 2个 *
  21.         // ***     // 第3层 有 3个 *
  22.         // ****    // 第4层 有 4个 *
  23.         // *****   // 第5层 有 5个 *
  24.         for (int i = 1; i <= 5; i++) {
  25.             // 控制打印每层的 * 的个数
  26.             for (int j = 1; j <= i; j++) {
  27.                 System.out.print("*");
  28.             }
  29.             // 每打印完一层的*后 就换行
  30.             System.out.println(""); // println 本身会换行
  31.         }
  33.         // 3.打印整个金字塔
  34.         //       *       // 第1层 有 1个 *   2 * 1 - 1  有4=(总层数-1)个空格
  35.         //      ***      // 第2层 有 3个 *   2 * 2 - 1  有3=(总层数-2)个空格
  36.         //     *****     // 第3层 有 5个 *   2 * 3 - 1  有2=(总层数-3)个空格
  37.         //    *******    // 第4层 有 7个 *   2 * 4 - 1  有1=(总层数-4)个空格
  38.         //   *********   // 第5层 有 9个 *   2 * 5 - 1  有0=(总层数-5)个空格
  39.         for (int i = 1; i <= 5; i++) {
  40.             // 在输出*之前，还要输出 对应的空格 = 总层数 - 当前层
  41.             for (int k = 1; k <= 5 - i; k++) {
  42.                 System.out.print(" ");
  43.             }
  45.             // 控制打印每层的 * 的个数
  46.             for (int j = 1; j <= 2 * i - 1; j++) {
  47.                 System.out.print("*");
  48.             }
  49.             // 每打印完一层的*后 就换行
  50.             System.out.println(""); // println 本身会换行
  51.         }
  53.         // 4.打印空心的金字塔 [最难的]
  54.         //       *       // 第1层 有 1个 *  当前行左右两端是*
  55.         //      * *      // 第2层 有 2个 *  当前行左右两端是*
  56.         //     *   *     // 第3层 有 2个 *  当前行左右两端是*
  57.         //    *     *    // 第4层 有 2个 *  当前行左右两端是*
  58.         //   *********   // 第5层 有 9个 *  全部输出*
  59.         for (int i = 1; i <= 5; i++) {
  60.             // 在输出*之前，还要输出 对应的空格 = 总层数 - 当前层
  61.             for (int k = 1; k <= 5 - i; k++) {
  62.                 System.out.print(" ");
  63.             }
  65.             // 控制打印每层的 * 的个数
  66.             for (int j = 1; j <= 2 * i - 1; j++) {
  67.                 // 当前行的两头是 * ，如果最后一层则全部输出 * 
  68.                 if (j == 1 || j == 2 * i - 1 || i == 5) {
  69.                     System.out.print("*");
  70.                 } else {  // 其他情况输出空格
  71.                     System.out.print(" ");
  72.                 }
  74.             }
  75.             // 每打印完一层的*后 就换行
  76.             System.out.println(""); // println 本身会换行
  77.         }
  79.         // 先死后活
  80.         // 层数 5 做成一个变量 int totalLevel = 5
  81.         // 引入 Scanner对象 
  82.         System.out.println("输入金字塔层数：");
  83.         int totalLevel = myScanner.nextInt();
  84.         for (int i = 1; i <= totalLevel; i++) {
  85.             // 在输出*之前，还要输出 对应的空格 = 总层数 - 当前层
  86.             for (int k = 1; k <= totalLevel - i; k++) {
  87.                 System.out.print(" ");
  88.             }
  90.             // 控制打印每层的 * 的个数
  91.             for (int j = 1; j <= 2 * i - 1; j++) {
  92.                 // 当前行的两头是 * ，如果最后一层则全部输出 * 
  93.                 if (j == 1 || j == 2 * i - 1 || i == totalLevel) {
  94.                     System.out.print("*");
  95.                 } else {  // 其他情况输出空格
  96.                     System.out.print(" ");
  97.                 }
  99.             }
  100.             // 每打印完一层的*后 就换行
  101.             System.out.println(""); // println 本身会换行
  102.         }
  103.     }
  104. }

九、跳转控制语句 - break

9.1 简单介绍

有的时候为了实现某种功能，需要不停的循环直到达到目标为止，但是这个过程循环了多少次我们不知道，所以在设计时我们只能让程序不停的循环执行，当达到目标时，我们用 break 终止循环。
break 语句用于终止某个语句块的执行，一般使用再 switch 或者循环 [ for、while、do-while ] 中

9.2 基本语法

{ ……..
break;
………..
}

9.3 break 流程图

Java基础：程序控制结构 - 图12

9.4 案例演示

Break01.java

  1. /**
  2.  * title: break 案例演示
  3.  */
  4. public class Break01 {
  6.     public static void main(String[] args) {
  7.         for (int i = 0; i < 10; i++) {
  8.             if (i == 3) {
  9.                 break;
  10.             }
  11.             System.out.println("i=" + i);
  12.         }
  13.         System.out.println("循环已终止，继续...");
  14.     }
  15. }

9.5 break 注意事项和细节说明

  1. break 语句出现在多层嵌套的语句中，可以通过标签指明要终止的是哪一层语句块

  2. 标签的基本使用
    label1: { ……
    label2: { ……
    label3: { ……
    break label2;
    ……
    }
    }
    }

    1. break 语句可以指定退出哪层
    2. label1 是标签，命名可由程序员指定
    3. break 后指定到那个 label 就退出到哪里
    4. 在实际的开发中，尽量不要使用标签
    5. 如果没有指定 label ，默认退出最近的循环体

BreakLabel.java

  1. /**
  2.  * title: 演示break-label
  3.  */
  4. public class BreakLabel {
  6.     public static void main(String[] args) {
  7.         label1:
  8.         for (int j = 0; j < 4; j++) {    // 外层 for
  9.             label2:
  10.             for (int i = 0; i < 10; i++) {   // 内层 for
  11.                 System.out.println("i=" + i);
  12.                 if (i == 2) {
  13.                     break label1;
  14.                 }
  15.             }
  16.             System.out.println("j=" + j);
  17.         }
  19.         System.out.println("");
  21.         abc1:
  22.         for (int j = 0; j < 4; j++) {
  23.             abc2:
  24.             for (int i = 0; i < 10; i++) {
  25.                 System.out.println("i=" + i);
  26.                 if (i == 2) {
  27.                     break;  // 不指定label 默认退出最临近的label(abc2)
  28.                 }
  29.             }
  30.             System.out.println("j=" + j);
  31.         }
  32.     }
  33. }

⏱ 小练习 [ for + break ]

  1. 1-100 以内的数求和，求出 当和第一次大于20的当前数
  2. 随机生成 1 -100的一个数，直到生成了97这个数，看看一共用了多少次？
    提示使用： (int)(Math.random() * 100) + 1 // 生成1-100随机数
  3. 实现登录验证，有3次机会，如果用户名为“丁真”，密码为“666”提示登录成功，否则提示还有几次机会
    提示：比较 String 使用 equals 方法，如下，
    1. String name = "贾宝玉";
    2. System.out.println(name.equals("贾宝玉"));
    3. System.out.println("贾宝玉".equals(name));  // 推荐使用，可以避免空指针

十、跳转控制语句 - continue

10.1 简单介绍

  1. continue 语句用于结束本次循环，继续执行下一次循环。
  2. continue 语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环，这个和 break 的标签使用规则一样。

10.2 基本语法

{ ……
continue;
……
}

10.3 continue 流程图

Java基础：程序控制结构 - 图13

10.4 案例演示

Continue.java

  1. /**
  2.  * title: continue 案例演示
  3.  */
  4. public class Continue {
  6.     public static void main(String[] args) {
  7.         int i = 0;
  8.         while (i <= 4) {
  9.             i++;
  10.             if (i == 2) {
  11.                 continue;
  12.             }
  13.             System.out.println("i = " + i);
  14.         }
  15.     }
  16. }

10.5 continue 细节说明

ContinueDetail.java

  1. public class ContinueDetail {
  3.     public static void main(String[] args) {
  4.         label1:
  5.         for (int j = 0; j < 4; j++) {
  6.             label2:
  7.             for (int i = 0; i < 10; i++) {
  8.                 if (i == 2) {
  9.                     // 看看分别输出什么值，并分析
  10.                     // continue;
  11.                     // continue label2;
  12.                     continue label1;
  13.                 }
  14.                 System.out.println("i = " + i);
  15.             }
  16.         }
  17.     }
  18. }

结合流程图，分析内存执行情况

十一、跳转控制语句 - return

11.1 简单介绍

return 使用在方法，表示跳出所在的方法，在讲解方法的时候会详细介绍，这里简单提一下。
注意：如果 return 写在 main 方法，退出程序…

11.2 案例演示

Return.java

  1. /**
  2.  * title: return 使用案例
  3.  */
  4. public class Return {
  6.     public static void main(String[] args) {    // main 方法
  7.         for (int i = 1; i <= 5; i++) {
  8.             if (i == 3) {
  9.                 System.out.println("韩顺平教育" + i);
  10.                 return;  // 退出程序
  11.             }
  12.             System.out.println("Hello World!");
  13.         }
  14.         System.out.println("go on...");
  15.     }
  16. }

十二、本章作业

  1. 编程实现如下功能
    某人有100,000元，每经过一次路口，需要交费，规则如下：

    1. 当现金 > 50000时，每次交 5%

    2. 当现金 <= 50000时，每次交1000

      编程计算该人可以经过多少次路口，要求：使用 while break 方式完成

  2. 实现判断一个整数，属于哪个范围：大于0，小于0，等于0

  3. 判断一个年份是否为闰年

  4. 判断一个整数是否是水仙花数（一个3位数，其各个位上数字立方和等于其本身，
    例如153 = 111+555+333）

  5. 看看下面代码输出什么？

    1. class Demo {
    2.  public static void main(String[] args) {
    3.      int m = 0,n = 3;
    4.      if (m > 0) {
    5.          if (n > 2) {
    6.              System.out.println("OK1");
    7.          } else {
    8.              System.out.println("OK2");
    9.          }
    10.      }
    11.  }
    12. }

  6. 输出1-100之间的不能被5整除的数，每5个一行

  7. 输出小写的a-z以及大写的Z-A

  8. 求出1-1/2+1/3-1/4……1/100的和

  9. 求1+(1+2)+(1+2+3)+(1+2+3+4)+……+(1+2+3+…+100)的结果

  1. import java.util.Scanner;
  2. public class ControlExercise01 {
  4.     public static void main(String[] args) {
  5.         double money = 100000;
  6.         int count = 0;
  7.         while (true) {
  8.             if (money < 1000) {
  9.                 break;
  10.             } else if (money <= 50000) {
  11.                 money -= 1000;
  12.                 count++;
  13.             } else {
  14.                 money *= 0.95;
  15.                 count++;
  16.             }
  17.         }
  18.         System.out.println("总共可以经过" + count + "条路口");
  20.         System.out.println("");
  22.         System.out.println("所有水仙花数：");
  23.         for (int i = 100; i < 1000; i++) {
  24.             int first = i / 100;
  25.             int mid = (i % 100) / 10;
  26.             int last = i % 10;
  27.             int flower = first * first * first + mid * mid * mid + last * last * last;
  28.             if (i == flower) {
  29.                 System.out.print(i + "\t");
  30.             }
  31.         }
  33.         System.out.println("");
  35.         // 输出1-100之间的不能被5整除的数，每5个一行
  36.         int lll = 1;
  37.         while(lll <= 100) {
  38.             for (int j = 1; j <= 5; j++) {
  39.                 if (lll % 5 != 0) {
  40.                     System.out.print(lll + "\t");
  41.                 }
  42.                 lll++;
  43.             }
  44.             System.out.println();
  45.         }
  46.         // 方法二：
  47.         out:
  48.         for (int i = 1; i <= 100; i++) {
  49.             inside:
  50.             for (int j = 1; j <= 5; j++) {
  51.                 if (i % 5 != 0) {
  52.                     System.out.print(i + "\t");
  53.                     continue out;
  54.                 }
  55.             }
  56.             System.out.println();
  57.         }
  59.         System.out.println();
  61.         // 输出小写的a-z以及大写的Z-A
  62.         for (char c1 = 'a'; c1 <= 'z'; c1++) {
  63.             System.out.print(c1 + " ");
  64.         }
  65.         System.out.println();
  66.         for (char c2 = 'Z'; c2 >= 'A'; c2--) {
  67.             System.out.print(c2 + " ");
  68.         }
  70.         System.out.println();
  72.         // 求出1-1/2+1/3-1/4......1/100的和
  73.         double plus = 0;
  74.         for (int i = 1; i <=100; i++) {
  75.             if (i % 2 != 0) {
  76.                 plus += 1.0 / i;
  77.             } else {
  78.                 plus -= 1.0 / i;
  79.             }
  80.         }
  81.         System.out.println(plus);
  83.         System.out.println();
  85.         // 求1+(1+2)+(1+2+3)+(1+2+3+4)+......+(1+2+3+...+100)的结果
  86.         int sum100 = 0;
  87.         // int sum2 = 0;
  88.         for (int i = 1; i <= 100; i++) {
  89.             for (int j = 1; j <=i; j++) {
  90.                 sum100 += j;
  91.             }
  92.         }
  93.         System.out.println("结果为" + sum100);
  94.     }
  95. }

学习参考（致谢）：

  1. B站 @程序员鱼皮 Java学习一条龙
  2. B站 @韩顺平 零基础30天学会Java