Java流程控制语句

1.1流程控制结构：

分为三类：

顺序结构：

分支结构：

if - else

switch - case

循环结构:

for

while

do - while

1.2分支结构之1 : if - else

在程序中 , 凡是遇到了需要使用分支结构的地方 , 都可以考虑使用if - else .

基本语法

1.格式

格式1 :

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

格式2 : "二选一"

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

格式3 : "多选一"

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

来一个案例:

class IfElseTest {
	public static void main(String[] args) {
		
		/*
		案例1：成年人心率的正常范围是每分钟60-100次。体检时，
		如果心率不在此范围内，则提示需要做进一步的检查。
		*/
		int heartBeats = 89;
		//错误的写法：if(60 <= heartBeats <= 100){

		if(heartBeats < 60 || heartBeats > 100){
			System.out.println("你需要做进一步的检查");
		}

		System.out.println("体检结束");

		//**********************************
		/*
		案例2：定义一个整数，判定是偶数还是奇数    
		*/
		int num = 13;
		if(num % 2 == 0){
			System.out.println(num + "是偶数");
		}else{
			System.out.println(num + "是奇数");
		}
	}
}

1.3 分支结构之2 : switch - case

在特殊的场景下 , 分支结构可以考虑使用switch - case

指定的数据类型 : byte \ short \ char \ int ; 枚举类(jdk5.0) \ String(jdk7.0)

可以考虑的常量值有限且取值情况不多.

特别之处 : case穿透

在能使用switch - case 的情况下 , 推荐使用switch - case , 因为比 if - else效率高

1.基本语法

switch(表达式)
{
    case 常量1:
        执行语句1;
        break;
    case 常量2:
        执行语句2;
        break;
    ......
    default:
        执行语句;
        break;
}

2.执行过程：

根据表达式中的值，依次匹配case语句。一旦与某一个case中的常量相等，那么就执行此case中的执行语句。

执行完此执行语句之后，

情况1：遇到break，则执行break后，跳出当前的switch-case结构

情况2：没有遇到break，则继续执行其后的case中的执行语句。 ---> case 穿透

...

直到遇到break或者执行完所有的case及default中的语句，退出当前的switch-case结构

3. 说明：

① switch中的表达式只能是特定的数据类型。如下：byte \ short \ char \ int \ 枚举(JDK5.0新增) \ String(JDK7.0新增)

② case 后都是跟的常量，使用表达式与这些常量做相等的判断，不能进行范围的判断。

③ 开发中，使用switch-case时，通常case匹配的情况都有限。

④ break:可以使用在switch-case中。一旦执行此break关键字，就跳出当前的switch-case结构

⑤ default：类似于if-else中的else结构。

default是可选的，而且位置是灵活的。

4. switch-case 与if-else之间的转换

① 开发中凡是可以使用switch-case结构的场景，都可以改写为if-else。反之，不成立

② 开发中，如果一个具体问题既可以使用switch-case，又可以使用if-else的时候，推荐使用switch-case。

为什么？switch-case相较于if-else效率稍高。

1.4循环结构之1 : for

凡是循环结构 , 都有四个要素 : ① 初始化条件 ②循环条件(是boolean类型) ③循环体 ④迭代条件

应用场景:有明确的遍历次数 . for(int i = 0; i <= 100; i ++)

基本语法

for循环的格式

for(①;②;④){

③

}

执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

案例 : 水仙花数

/*
题目：输出所有的水仙花数，所谓水仙花数是指一个3位数，其各个位上数字立方和等于其本身。
例如： 153 = 1*1*1 + 3*3*3 + 5*5*5
*/
class ForTest1 {
	public static void main(String[] args) {
		
		//遍历所有的3位数
		for(int i = 100;i <= 999;i++){
			
			//针对于每一个三位数i，获取其各个位上数值
			int ge = i % 10;
			int shi = i / 10 % 10;  //或 int shi = i % 100 / 10
			int bai = i / 100;

			//判断是否满足水仙花数的规则
			if(i == ge * ge * ge + shi * shi * shi + bai * bai * bai){
				System.out.println(i);
			}

		}
	}
}

1.5循环结构之2 : while

应用场景 : 没有明确的遍历次数

1. 凡是循环结构，就一定会有4个要素：

① 初始化条件

② 循环条件 ---> 一定是boolean类型的变量或表达式

③ 循环体

④ 迭代部分

2.while的格式

①

while(②){

③

④

}

3.执行过程：① - ② - ③ - ④ - ② - ③ - ④ - ... - ②

4. for循环与while循环可以相互转换！

5. for循环和while循环的小区别：

初始化条件的作用域范围不同。while循环中的初始化条件在while循环结束后，依然有效。

案例 : 计算折纸成珠穆朗玛峰的高度

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

*/
class WhileTest2 {
	public static void main(String[] args) {
		
		//1. 声明珠峰的高度、纸的默认厚度
		double paper = 0.1;//单位：毫米
		double zf = 8848860;//单位：毫米
		

		//2. 定义一个变量，记录折纸的次数
		int count = 0;


		//3. 通过循环结构，不断调整纸的厚度 （当纸的厚度超过珠峰高度时，停止循环）
		while(paper <= zf){
			
			paper *= 2;
			count++;

		}
		
		System.out.println("paper的高度为:" + (paper / 1000) + ",超过了珠峰的高度" + (zf/1000));
		System.out.println("共折纸" + count + "次");


	}
}

1.6 循环结构之3 : do - while

至少会执行一次循环体 .

开发中 , 使用的较少 .

1. 凡是循环结构，就一定会有4个要素：

① 初始化条件

② 循环条件 ---> 一定是boolean类型的变量或表达式

③ 循环体

④ 迭代部分

2. do-while的格式

①

do

{

③

④

}while(②);

执行过程：① - ③ - ④ - ② - ③ - ④ - .... - ②

3. 说明：

1) do-while循环至少执行一次循环体。

2) for、while、do-while循环三者之间是可以相互转换的。

3) do-while循环结构，在开发中，相较于for、while循环来讲，使用的较少。

案例 : 模拟ATM取款

/*
题目：模拟ATM取款

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

=========ATM========
   1、存款
   2、取款
   3、显示余额
   4、退出
请选择(1-4)：
*/
import java.util.Scanner;
class DoWhileTest1 {
	public static void main(String[] args) {
		
		//1. 定义balance的变量，记录账户余额
		double balance = 0.0;
		boolean flag = true; //控制循环的结束
		Scanner scan = new Scanner(System.in);//实例化Scanner
		do
        {
			//2. 声明ATM取款的界面
			System.out.println("=========ATM========");
			System.out.println("   1、存款");
			System.out.println("   2、取款");
			System.out.println("   3、显示余额");
			System.out.println("   4、退出");
			System.out.print("请选择(1-4)：");
			//3. 使用Scanner获取用户的选择
			int selection = scan.nextInt();
			switch(selection){
				//4. 根据用户的选择，决定执行存款、取款、显示余额、退出的操作
				case 1:
					System.out.print("请输入存款的金额：");
					double money1 = scan.nextDouble();
					if(money1 > 0){
						balance += money1;
					}
					break;
				case 2:
					System.out.print("请输入取款的金额：");
					double money2 = scan.nextDouble();
					if(money2 > 0 && money2 <= balance){
						balance -= money2;
					}else{
						System.out.println("输入的数据有误或余额不足");
					}
					break;
				case 3:
					System.out.println("账户余额为：" + balance);
					break;
				case 4 :
					flag = false;
					System.out.println("感谢使用，欢迎下次光临^_^");
					break;
				default:
					System.out.println("输入有误，请重新输入");
					//break;
			}
		}while(flag);
		//关闭资源
		scan.close();
	}
}

1.7"无限循环"

基本语法

1. 格式：

while(true) 或 for(;;)

2.开发中，有时并不确定需要循环多少次，需要根据循环体内部某些条件，来控制循环的结束（使用break）。

3. 如果此循环结构不能终止，则构成了死循环！开发中要避免出现死循环。

案例 ; 从键盘读入个数不确定的整数

/*
案例：从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束程序。
*/
import java.util.Scanner;
class ForWhileTest1 {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int positiveCount = 0;//记录正数的个数
		int negativeCount = 0;//记录负数的个数
		for(;;){//while(true){
			System.out.print("请输入一个整数(输入为0时结束程序)：");
			int num = scan.nextInt(); //获取用户输入的整数
			if(num > 0){ //正数
				positiveCount++;
			}else if(num < 0){ //负数
				negativeCount++;
			}else{ //零
				System.out.println("程序结束");
				break;
			}
		}
		System.out.println("正数的个数为：" + positiveCount);
		System.out.println("负数的个数为：" + negativeCount);
		scan.close();
	}
}

1.8嵌套循环

基本语法

1. 嵌套循环：

是指一个循环结构A的循环体是另一个循环结构B。

- 外层循环：循环结构A

- 内层循环：循环结构B

2. 说明：

1）内层循环充当了外层循环的循环体。

2）对于两层嵌套循环来说，外层循环控制行数，内层循环控制列数。

3）举例：外层循环执行m次，内层循环执行n次，则内层循环的循环体共执行m * n次

4）实际开发中，我们不会出现三层以上的循环结构，三层的循环结构都很少见。

案例

/*
练习：九九乘法表
*/
class NineNineTable {
	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();
		}
	}
}

1.9关键字break , continue

1. break和continue关键字的使用

使用范围 在循环结构中的作用 相同点

break: switch-case

循环结构中 结束（或跳出）当前循环结构 在此关键字的后面不能声明执行语句。

continue: 循环结构中 结束（或跳出）当次循环 在此关键字的后面不能声明执行语句。

2. 了解带标签的break和continue的使用

在嵌套中 ， 可以直接跳出指定的循环

3. 开发中，break的使用频率要远高于continue。

1.11Scanner类的使用

如何从键盘获取不同类型（基本数据类型、String类型）的变量：使用Scanner类。

1. 使用Scanner获取不同类型数据的步骤

步骤1：导包 import java.util.Scanner;

步骤2：提供（或创建）一个Scanner类的实例

步骤3：调用Scanner类中的方法，获取指定类型的变量 (nextXxx())

步骤4：关闭资源，调用Scanner类的close()

2. Scanner类中提供了获取byte \ short \ int \ long \float \double \boolean \ String类型变量的方法。

注意，没有提供获取char类型变量的方法。需要使用next().charAt(0)

1.12 获取随机数

1. 可以使用Java提供的API:Math类的random()

2. random()调用以后，会返回一个[0.0,1.0)范围的double型的随机数

3. 需求1：获取一个[0,100]范围的随机整数？

需求2：获取一个[1,100]范围的随机整数？

4. 需求：获取一个[a,b]范围的随机整数？

(int)(Math.random() * (b - a + 1)) + a

另一个方法 ,

导入一个import java.util.Scanner;的包

然后写一个Random r = new Random( );

然后在学习之余 ， 也可以多看看算法课 ， 会对自己的代码能力有不小的提高