04程序控制语句

##   概述

在程序中，程序运行的流程控制决定程序是如何执行的，主要有三大流程控制语句：

- 顺序控制
- 分支控制
- 循环控制

## 顺序控制

> 概述

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

Java语言中定义变量时采用合法的前向引用，例如：

```java
public class Test{
    int num1 = 1;
    int num2 = num1 + 1;
}
```

> 图示

![image-20230118152958616](https://oss.maolin101.com/202501070046932.png-101.webp)

## 分支控制

> 概述

让程序有选择的执行，分支控制有三种：

- 单分支语句，if
- 多分支语句，if - else
- 多分支语句，if - else if - else

> 单分支

语法

```java
if（条件表达式）{
    代码块；
}
```

Tips：

- 当条件表达式执行结果为true时，则执行{}里的代码块；当条件表达式执行结果为false时，则不执行；
- 如果{ }中只有一条语句，则可以不用{ }

流程图

![image-20230118174230675](https://oss.maolin101.com/202501070046933.png-101.webp)

示例

```java
// 导入包
import java.util.*;

public class If01{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("输入您的分数：");
		int score = myScanner.nextInt();
		if(score > 60){
			System.out.println("及格");
		}
	}
}	
```

![image-20230118174132035](https://oss.maolin101.com/202501070046934.png-101.webp)

> 双分支

语法

```java
if（条件表达式）{
    代码块1；
}
else{
    代码块2；
}
```

Tips：当条件表达式执行结果为true时，执行代码块1；当条件表达式执行结果为false时，执行代码块2；

流程图

![image-20230118200609126](https://oss.maolin101.com/202501070046935.png-101.webp)

示例

需求：18岁以上（包含18岁）显示允许，18岁以下显示未达到合适年龄。

```java
import java.util.Scanner;
public class If02{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入您的年龄：");
		int age = myScanner.nextInt();
		if(age >= 18){
			System.out.println("合格！");
		}
		else{
			System.out.println("未达到要求年龄！");
		}
	}
}
```

![image-20230118201457253](https://oss.maolin101.com/202501070046936.png-101.webp)

> 多分支

语法

```
if（条件表达式）{
	代码块1；
}
else if{
	代码块2；
}
else{
	代码块n；
}
```

Tips：

- 在多分支中可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有
- 如果有else，如果所有的条件表达式都不成立，则默认执行else中的代码块n

流程图

![image-20230118201849847](https://oss.maolin101.com/202501070046937.png-101.webp)

示例

需求：输入当前的信用分数，分数为100分显示信用极好；分数为80-99[包含80与99]显示信用优秀；分数为60-80[包含60，不包含80]显示信用一般，其他情况显示不及格；

```java
import java.util.Scanner;
public class If03{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入您的信用分数：");
		int score = myScanner.nextInt();
		if(score == 100){
			System.out.println("信用极好");
		}
		else if(score > 80 && score <= 99){
			System.out.println("信用优秀");			
		}
		else if(score >= 60 && score < 80){
			System.out.println("信用一般");
		}
		else{
			System.out.println("不及格");
		}
	}
} 
```

![image-20230118204607648](https://oss.maolin101.com/202501070046938.png-101.webp)

## 嵌套分支

> 概述

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支结构称为内层分支，外面的分支结构称为外称分支。

> 语法

```java
if{
    if(){
        
    }
    else{
        
    }
}
```

> 示例

比赛规则，如果初赛成绩大于8.0则进入决赛，否则淘汰，进入决赛后会根据选手的性别进入男子组或女子组；

```java
import java.util.Scanner;
public class If04{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入选手的最终得分：");
		double score = myScanner.nextDouble();
		if(score > 8.0){
			System.out.print("该选手进入决赛,请输入选手的性别：");
			char gender = myScanner.next().charAt(0);
			if(gender == '男'){
				System.out.println("进入男子组");
			}
			else{
				System.out.println("进入女子组");
			}
		}
		else{
			System.out.println("该选手已被淘汰");
		}

}
}
```

![image-20230118220354124](https://oss.maolin101.com/202501070046939.png-101.webp)

## switch分支结构

> 语法

```java
switch(表达式){
    case 常量1:
        代码块1;
        break;
    case 常量2:
        代码块2;
        break;
    case 常量n:
        代码块n;
        break;
    default:
        default代码块;
        break;
        
}
```

Tips：

- 如果表达式的值等于常量1，则执行代码块1；
- 如果表达式的值不等于常量1，则继续向下匹配case 对于的常量值；
- 如果表达式的值没有匹配上case 对应的常量值，则执行default对应的default代码块；
- break语句的作用为代码块执行结束之后，跳转switch分支语句；
- 表达式的返回值必须时byte、short、int、char、enum、String；

> 流程图

![image-20230119110043996](https://oss.maolin101.com/202501070046940.png-101.webp)

> 练习

题目：考试得分有四个等级，A - 优秀，B - 良好， C - 及格，D - 未达标，输入其他字符 - 请重新输入

```java
import java.util.Scanner;
public class Switch01{
	public static void main(String[] agrs){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请您输入考核等级：");
		char level = myScanner.next().charAt(0);
		switch(level){
			case 'A':
				System.out.println("优秀");
				break;
			case 'B':
				System.out.println("一般");
				break;
			case 'C':
				System.out.println("及格");
				break;
			case 'D':
				System.out.println("未达标");
				break;
			default:
				System.out.println("未识别，请您重新输入");
				break;
		}
	}
}
```

![image-20230119111057160](https://oss.maolin101.com/202501070046941.png-101.webp)

> return

当return用在方法时，表示跳出方法；当return用在main里面时，表示退出程序；

## for循环

代码可以循环执行

> 语法

```java
for(循环变量初始化;循环条件;循环变量迭代){
    代码块;
}
```

Tips:

- for 关键字，表示循环控制；
- for循环四要素：循环变量初始化，循环条件，循环操作，循环变量迭代；
- 如果代码块中只有一条语句，可以省略{ }；

> 流程图

![image-20230119111835861](https://oss.maolin101.com/202501070046942.png-101.webp)

> 输出10行相同语句

```java
public class For01{
	public static void main(String[] args){
		for(int i = 1; i < 11; i++){
			System.out.println("第" + i + "次："+ "xbxaq.com");
		}
	}
}
```

![image-20230119112356989](https://oss.maolin101.com/202501070046943.png-101.webp)

> 打印1~100之间是9倍数的整数，统计个数与总和

```java
public class For02{
	public static void main(String[] args){
		// 个数
		int num = 0;
		// 总和
		int sum = 0;
		for(int i = 1; i < 101; i++){
			if(i % 9 == 0){
				sum += i;
				num += 1;

}
		}
		System.out.println("100以内的9倍数的个数为" + num);
		System.out.println("100以内的9倍数整数的总和为" + sum);
	}
}
```

![image-20230119113427653](https://oss.maolin101.com/202501070046944.png-101.webp)

> 用代码实现以下的语句

```
0 + 5 = 5
1 + 4 = 5
2 + 3 = 5
3 + 2 = 5
4 + 1 = 5
5 + 0 = 5
```

```java
public class For03{
	public static void main(String[] args){
		int y = 5;
		for(int i = 0;i <= 5; i++,y--){
			System.out.println(i + " + " + y + " = " + (i + y));
		}
	}
}
```

![image-20230119114241732](https://oss.maolin101.com/202501070046945.png-101.webp)

## while循环

> 语法

```java
while(循环条件){
    代码块-循环语句;
    循环变量迭代;
}
```

Tips：while循环先判断再执行语句

> 流程图

![image-20230119114414726](https://oss.maolin101.com/202501070046946.png-101.webp)

> 输出10行相同语句

```java
public class While01{
	public static void main(String[] args){
		int i = 1;
		while(i < 11){
			System.out.println("第" + i + "次：" + "xbxaq.com");
			i += 1;
		}
	}
}
```

![image-20230119130533289](https://oss.maolin101.com/202501070046947.png-101.webp)

> 打印1-100之间所有能被3整除的数

```java
public class While02{
	public static void main(String[] args){
		int i = 1;
		while(i < 101){
			if(i % 3 == 0){
				System.out.println(i);
			}
			i += 1;
		}
	}
}
```

![image-20230119131143371](https://oss.maolin101.com/202501070046948.png-101.webp)

## do...while循环

> 语法

```
do{
	代码块；
	循环变量迭代；
}while(循环条件)；
```

Tips：先执行，再判断（至少执行一次），最后有个分号

> 流程图

![image-20230119132910648](https://oss.maolin101.com/202501070046949.png-101.webp)

> 练习

```java 
public class DoWhile01{
	public static void main(String[] args){
		int i = 1;
		do{
			System.out.println("小白学安全");
			i += 1;
		}while(i > 5);
		System.out.println("xbxaq.com");
	}
}
```

![image-20230119133308659](https://oss.maolin101.com/202501070046950.png-101.webp)

## 多重循环

> 概述

将一个循环放在另一个循环体内，则形成嵌套循环，其中for、while、do...while都可作为外层循环和内层循环。

多重循环的本质就把内层循环当成外层循环的循环体，只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层循环的当次循环，开始下一次循环。

> 案例-9*9乘法表

```java
public class Double{
	public static void main(String[] args){
		for(int i = 1; i < 10; i++){
			System.out.println();
			for(int y = 1; y < (i + 1); y++){
				System.out.print(y + "*" + i + "=" + (i * y) + ' ');
			}
		}
	}
}
```

![image-20230119143405468](https://oss.maolin101.com/202501070046951.png-101.webp)

## 跳转控制语句

> break

break语句用于终止某个语句块的执行，一般使用在switch或循环语句中，跳出循环。

**练习**

```java
public class Break01{
	public static void main(String[] args){
		for(int i = 1;i < 5; i++){
			if(i == 3){
				System.out.println("666");
				break;
			}
			System.out.println("777");
		}
	}
}
```

![image-20230119144445391](https://oss.maolin101.com/202501070046952.png-101.webp)

> continue

continue语句用于结束本次循环，继续执行下一次循环。

**练习**

```java
public class Break01{
	public static void main(String[] args){
		for(int i = 1;i < 5; i++){
			if(i == 3){
				System.out.println("666");
				// break;
				continue;
			}
			System.out.println("777");
		}
	}
}
```

![image-20230119144651968](https://oss.maolin101.com/202501070046953.png-101.webp)

## 练习

> 1、某人有100,000元，每经过一次路口，需要交过路费，规则如下：1.当现金>50000时，每次交5%；2.当现金<=50000时，每次交1000；
>
> 问：该人可以经过多少次路口？

```java
public class HomeWork01{
	public static void main(String[] args){
		double money = 100000;
		int count = 0;
		while(true){
			if(money > 50000){
				money *= 0.95;
				count ++;
			}
			else if(money >= 1000){
				money -= 1000;
				count++;
			}
			else{
				break;
			}
		}
		System.out.println(count);
	}
}
```

![image-20230130145942460](https://oss.maolin101.com/202501070046954.png-101.webp)

> 2、判断输出的整数是否为水仙花数
>
> 所谓的水仙花数是指一个三位数，其各个位上的数字立方和等于其本身，例如：153 = 1\*1*1 + 5\*5\*5 +3\*3\*3

```java
import java.util.Scanner;
public class HomeWork02
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入一个整数用于检测是否为水仙花数：");
		int n = myScanner.nextInt();
		int n3 = n / 100;
		int n2 = n % 100 / 10;
		int n1 = n % 10;
		if(n1 * n1 * n1 + n2 * n2 * n2 + n3 * n3 * n3 == n){
			System.out.println(n + "是水仙花数");
		}
		else{
			System.out.println(n + "不是水仙花数");
		}
		
	}
}
```

![image-20230130151826315](https://oss.maolin101.com/202501070046955.png-101.webp)

> 3、判断输入的年份是否是闰年

```java
/**
 * 判断输入的年份是否为闰年，需要满足的条件：
 * 1、可以被4整除且不能被100整除；
 * 2、可以被400整除；
 */
import java.util.Scanner;
public class HomeWork03{
	public static void main(String[] args){
		Scanner myScanner = new Scanner(System.in);
		System.out.print("请输入年份：");
		int year = myScanner.nextInt();
		if(year % 4 == 0 && year % 100 != 0){
			System.out.println(year + "是闰年");
		}
		else if(year % 400 ==0){
			System.out.println(year + "是闰年");	
		}
		else{
			System.out.println(year + "不是闰年");
		}
	}
}
```

![image-20230130152950680](https://oss.maolin101.com/202501070046956.png-101.webp)