第5章：程序控制结构

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。
● 1) 顺序结构
● 2) 选择结构
● 3) 循环结构

5.1 顺序结构

程序从上到下逐行地执行，中间没有任何判断和跳转，就叫做顺序结构。

顺序结构举例和注意事项
● Java中定义变量时，采用合法的前向引用（也就是说先定义后使用）如：

public class Test{
   
    int num 1 = 12;
    int num2 = num1 + 2;
}

// 错误形式
/*public class Test{
    int num2 = num1 + 2;
    int num1 = 12;
}*/
1
2
3
4
5
6
7
8
9
10
11

5.2 选择结构 if-else

让程序有选择的的执行,选择结构有三种
● 1) 单分支 if
● 2) 双分支 if-else
● 3) 多分支 if-else if -…-else

5.2.1 单分支

基本语法

if(条件表达式){
   
    执行代码块;(可以有多条语句)
}
1
2
3
4

说明：当条件表达式为true时，就会执行{ }的代码。如果为false，就不执行。

特别说明：如果{ }中只有一条语句，则可以不用{ }，爱摸鱼的TT~建议写上{ }

案例说明

编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责”

import java.util.Scanner;
public class If01{
   
	public staitc void main(String[] args){
   
		//需求：
		//编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责”
		//思路分析：
		//1.接收输入的年龄，应该定义一个Scanner对象
		//2.把年龄保存到一个int age变量中
		//3.使用if判断，是否满足条件
		//代码实现
		
		//定义Scanner对象
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入您的年龄：")
		//把年龄保存到一个变量 int age
		int age = myScanner.nextInt();
		//使用 if 判断，输出对应信息
		if(age > 18){
   
			Ssytem.out.println("你年龄大于18，要对自己行为负责");
		}

		System.out.println("程序继续...");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

5.2.2 双分支

基本语法：

if(条件表达式){
   
    执行代码块1；
}else{
   
    执行代码块2;
}
1
2
3
4
5
6
7

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

案例演示

编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责”，否则，输出“你的年龄不大这次就原谅你。”

import java.util.Scanner;
public class If01{
   
	public static void main(String[] args){
   
		//需求：
		//编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出“你年龄大于18，要对自己的行为负责”
		//否则，输出“你的年龄不大这次就原谅你。”
		//思路分析：
		//1.接收输入的年龄，应该定义一个Scanner对象
		//2.把年龄保存到一个int age变量中
		//3.使用if-else判断，是否满足条件
		//代码实现
		
		//定义Scanner对象
		Scanner myScanner = new Scanner(System.in);
		System.out.println("请输入您的年龄：");
		//把年龄保存到一个变量 int age
		int age = myScanner.nextInt();
		//使用 if 判断，输出对应信息
		if(age > 18){
   
			System.out.println("你年龄大于18，要对自己行为负责");
		}else{
   
			System.out.println("你年龄不大这次就原谅你。");
		}

		System.out.println("程序继续...");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

5.2.3 单分支和双分支练习题

1. 编写程序，声明 2 个 double 型变量并赋值。判断第一个数大于 10.0，且第 2 个数小于 20.0，打印两数之和。
   public class IfExercise01{

	public static void main(String[] args){
   
		//需求：
		//编写程序，声明 2 个 double 型变量并赋值。判断第一个数大于 10.0，且第 2 个数小于 20.0，打印两数之和。
		//思路分析：
		//1.定义两个double a,b变量，并随便赋值
		//2.使用if语句判断条件是否满足
		
		double a = 12.2;
		double b = 5.6;
		if(a > 10.0 && b < 20.0){
   
			System.out.println("两数之和为：" + (a + b));
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

2. 定义两个变量 int，判断二者的和，是否能被 3 又能被 5 整除，打印提示信息

public class IfExercise01{
   
	public static void main(String[] args){
   
		//需求：
		//定义两个变量 int，判断二者的和，是否能被 3 又能被 5 整除，打印提示信息 
		//思路分析：
		//1.自定义两个变量 int a，b
		//2.定义一个int sum变量保持二者之和
		//3. sum % 3 , 5 后 等于 0 说明可以整除 
		//4. 使用 if - else 来提示对应信息
		//代码实现
		
		int a = 10,b = 1;
		int num = a + b;
		if( num % 3 == 0 && num % 5 == 0){
   
			System.out.println("和可以被 3 又能被 5 整除");
		}else{
   
			System.out.println("和不能被 3 和 5 整除..");
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

3. 判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被 4 整除，但不能被 100 整除；(2)能被 400 整除 。

public class IfExercise01{
   
	public static void main(String[] args){
   
		//需求：
		//判断一个年份是否是闰年，闰年的条件是符合下面二者之一：
		//(1)年份能被 4 整除，但不能被 100 整除；(2)能被 400 整除 。
		//思路分析：
		//1.定义一个int year 保存年
		//2.年份能被 4 整除，但不能被 100 整除, // => year % 4 == 0 && year % 100 != 0 
		//3. 能被 400 整除 => year % 400 == 0 
		//4. 上面的 2 和 3 是 或的关系
		//代码实现
		
		int year = 2022;
		if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){
   
			System.out.println(year + " 是 闰年"); 
		} else {
    
			System.out.println(year + " 不是 闰年"); 
		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

5.2.4 多分支

基本语法：

if(条件表达式1){
   
    执行代码块1;
}else if(条件表达式2){
   
    执行代码块2;
}
...
else{
   
    执行代码块n;
}
1
2
3
4
5
6
7
8
9
10
11
12

特别说明：
（1）多分支，可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有；
（2）如果有else，如果所有的条件表达式都不成立，则默认执行else代码块。

多分支的流程图（重要）

说明：

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

案例演示

请输入保国同志的芝麻信用分：
如果：
● 1) 信用分为 100 分时，输出 信用极好；
● 2) 信用分为(80，99]时，输出 信用优秀；
● 3) 信用分为[60,80]时，输出 信用一般；
● 4) 其它情况 ，输出 信用 不及格 ；
● 5) 请从键盘输入保国的芝麻信用分，并加以判断。

//课堂练习
import java.util.Scanner;
public class If03 {
    

	//编写一个main方法
	public static void main(String[] args) {
   
		/*
		输入保国同志的芝麻信用分：
		如果：
		信用分为100分时，输出 信用极好；
		信用分为(80，99]时，输出 信用优秀；
		信用分为[60,80]时，输出 信用一般；
		其它情况 ，输出 信用 不及格 
		请从键盘输入保国的芝麻信用分，并加以判断
		假定信用分数为int
		 */
		
		Scanner myScanner = new Scanner(System.in);
		//接收用户输入
		System.out.println("请输入信用分(1-100):");
		//请思考：如果小伙伴输入的不是整数，而是hello..
		//==>这里我们后面可以使用异常处理机制搞定-》爱摸鱼的TT~点一下
		int grade = myScanner.nextInt();

		//先对输入的信用分，进行一个范围的有效判断 1-100, 否则提示输入错误

		if(grade >=1 && grade <= 100) {
   
			//因为有4种情况，所以使用多分支
			if(grade == 100) {
   
				System.out.println("信用极好");
			} else if (grade > 80 && grade <= 99) {
    //信用分为(80，99]时，输出 信用优秀；
				System.out.println("信用优秀");
			} else if (grade >= 60 && grade <= 80) {
   //信用分为[60,80]时，输出 信用一般
				System.out.println("信用一般");
			} else {
   //其它情况 ，输出 信用 不及格 
				System.out.println("信用不及格");
			}

		} else {
   
			System.out.println("信用分需要在1-100,请重新输入:)");
		}

	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

5.2.5 嵌套分支

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支，外面的分支结构称为外 层分支。爱摸鱼的TT~建议: 不要超过 3 层 （可读性不好）

基本语法：

if(){
   
1