Java 语言基本语法（流程控制）

Java 语言基本语法（流程控制）

1. 顺序结构
   程序从上到下逐次的执行 中间没有任何判断和跳转
2. 分支结构
   • 根据条件 选择性的执行某段代码
   • 有 if-else 和 switch 两种分支语句
3. 循环结构
   • 根据循环条件 循环性的执行某段代码
   • 有 for/while/do-while 三种循环语句
   • 注：JDK1.5 提供了 foreach 循环 方便遍历集合 数组元素

分支结构

1. if-else

if-else（条件判断结构）
有三种结构

1. if (条件表达式) {
   执行代码块;
   }
2. 二选一（一定会选择代码块中的一个执行）
   if (条件表达式) {
   执行代码块;
   } else {
   执行代码块;
   }
3. 多选一（多选一 选择执行后直接跳出）
   if (条件表达式) {
   执行代码块;
   } else if {
   执行代码块;
   ... .. .
   } else {
   执行代码块;
   }
4. 说明：
   • 如果多个条件表达式之间是“互斥”关系（或者没有交集的关系）那个判断和执行语句声明在上面还是下面 无所谓
   • 如果多个条件表达式之间有交集关系 需要根据实际情况 考虑清楚应该将那个结构声明在上面
   • 如果多个条件表达式之间有包含关系 通常情况下 需要将范围小的声明在范围大的上面 否则范围小的可能不会执行
   • if 执行后只有单行可取消“{}”（可能后续修改程序会出错 谨慎使用）省去“{}”后 if 的代码域只有单行 且 else 配对 if（寻找路线是就近原则） 遇见试题需要谨慎... .. .
   • 多重 if 语句 在条件表达式不满足的情况下 会进行下一个条件表达式的判断 当前面的条件表达式均不成立时 才会执行 else 块内的代码

2. （番外）如何从键盘获取值

1. 导包 import java.util.Scanner;
2. Scanner 的实例化（System.in ---> 表示从键盘输入）
3. 获取值 int/float/double... ---> nextInt()/Float()...; 获取 String ---> next()/nextLine();

注意：需要根据相应的方法 来输入指定类型的类 如果输入的类型与要求类型不匹配时 会报异常 会导致程序终止

	Scanner input = new Scanner(System.in);
	System.out.println("请输入学生成绩！");
	double number = input.nextDouble();
	if (number == 100.0) {
		System.out.println("成绩：" + number + "\t等级：A");
	} else if (number >= 80.0) {
		System.out.println("成绩：" + number + "\t等级：B");
	} else if (number >= 60.0) {
		System.out.println("成绩：" + number + "\t等级：C");
	} else {
		System.out.println("成绩：" + number + "\t等级：D");
	}

3. （番外）如何获取随机数

	// 获取一个随机数
	// double value = Math.random() * 100;// 这样是[0.0,100.0)
        // double value = Math.random() * 90 + 10;// [10.0,100.0)
	int value = (int)(Math.random() * 90 + 10);// [0.0,1.0) ---> [0.0,90.0) ---> [10.0,100.0) ---> [10,99]
	// 公式：闭区间[a,b]：(int)(Math.random() * (b - a + 1) + a)；

4. "equals"和"=="的区别

1. "=="比较基本数据类型所存储的值
2. "equals"比较引用数据类型的所引用的值

5. switch-case

1. switch-case 它是一个入口 根据 switch() 表达式的值 依次匹配各个 case 中的常量 一旦匹配成功 则进入相应的 case 结构中 调用其执行语句 当执行完调用的语句后则仍然向下执行其他 case 结构中的执行语句 直到遇见 break 关键字或执行到此 switch-case 结构的末尾为止（要想实现多选一结构 需要在每个 case 执行语句后添加 break 关键字）
2. break 可以使用在 switch-case 结构中 表示一但执行到此关键字 就跳出 switch-case 结构
3. switch 结构中的表达式"switch(表达式)" 只能是如下六种数据类型之一
   （byte char short int 枚举类型（JDK5.0新增） String（JDK7.0新增））（这是规定... .. .）
4. case 之后只能声明常量 不能声明范围
5. break 关键字是可选的（switch 结构之外）
6. default（默认值/备选）（case 之外/情况之外）default 相当于 if-else 中的 else 都是可选的（default 的位置是可选的 但是程序执行优先考虑 case）

	/*
    编写程序 输入日期 判断是2020年的第几天
    日期 判断所输入月份当月的天数
    月份 判断除当月后 有几个月
    利用switch语句进行编写代码
    */
    System.out.println("请输入月份！");
    int month = input.nextInt();
    System.out.println("请输入日期！");
    int day = input.nextInt();
    int sumDay = 0;
    switch (month) {
    case 12:
        sumDay += 30;
    case 11:
        sumDay += 31;
    case 10:
        sumDay += 30;
    case 9:
        sumDay += 31;
    case 8:
        sumDay += 31;
    case 7:
        sumDay += 30;
    case 6:
        sumDay += 31;
    case 5:
        sumDay += 30;
    case 4:
        sumDay += 31;
    case 3:
        sumDay += 30;
    case 2:
        sumDay += 31;
    case 1:
        sumDay += day;
    }
    System.out.println("2020年" + month + "月" + day + "日\t" + "是2020年的第" + sumDay + "天！" );
    /*
    1. 凡是可以使用switch-case结构 都可以转换if-else 反之不成立
	2. 我们写分支结构时 当发现即可使用switch-case结构又能使用if-else 我们优先使用switch-case（当然 case不能太多... .. .）原因是swtich-case执行效率更高
     */

循环结构

1. for 循环
2. while 循环
3. do-while 循环

循环语句的四个组成部分

1. 初始化部分
2. 循环条件部分 ---> 循环条件是布尔类型
3. 循环体部分
4. 迭代部分

for 循环

1. for 循环条件四要素

   • 初始化条件
   • 循环条件
   • 循环体
   • 迭代条件

2. for 循环的结构
   for (①;②;④) {
   ③
   }
   执行过程：① ---> ② ---> ③ ---> ④ ---> ② ---> ③ ---> ④ ---> --- -- -> ②不满足条件 ---> 出结构

		// 练习： 遍历100以内的偶数/能被2除尽的类
		for (int i = 1; i <= 100; i++) {
			if (i % 2 == 0) {
				System.out.println(i);
			}
		}

while 循环

循环语句的四个组成部分

1. 初始化部分
2. 循环条件部分 ---> 循环条件是布尔类型
3. 循环体部分
4. 迭代部分

①;
while (②) {
③;
④;
}
执行过程：① ---> ② ---> ③ ---> ④ ---> ② ---> ③ ---> ④ ---> --- -- -> ②不满足条件 ---> 出循环

说明：

1. while 循环条件四（迭代条件）不能缺少 否则导致死循环 我们写程序需要避免死循环
2. 开发中 我们基本都是使用 while 和 for 两种循环 （for 和 while 可以互相转换（无缝转换））如果是遍历数组/字符串等 通常使用 for 如果初始化条件非常复杂通常使用 while

算法特征：有限性（不能无限执行）

do-while 循环

（开发中常使用for/while）
循环语句的四个组成部分

1. 初始化部分
2. 循环条件部分 ---> 循环条件是布尔类型
3. 循环体部分
4. 迭代部分

①
do {
③
④
} while (②);

执行过程：① ---> ③ ---> ④ ---> ② ---> ③ ---> ④ ---> --- -- -> ②不满足条件 ---> 循环终止

说明：do-while 循环至少会执行一次循环体 如果多次执行循环体 结果和 for/while 循环一致

无限循环的使用（while(true)/for( ; ; )）

	/* 无限循环的使用（while(true)/for( ; ; )）
	从键盘读入个数不确定的整数 并判断输入的正数和负数的个数 输入为0时结束
	*/
	Scanner input = new Scanner(System.in);
	int number = 0;
        int positiveNumber = 0;
        int negativeNumber = 0;
        while (true) {
            System.out.println("Please input number!");
            number = input.nextInt();
            if (number > 0) {
                positiveNumber++;
            } else if (number < 0) {
                negativeNumber++;
            } else {
            	System.out.println("positiveNumber: " + positiveNumber);
        		System.out.println("negativeNumber: " + negativeNumber);
        		System.out.println("game over!");
                break;
            }
        }
        // 结束循环的两种方式 1.返回false 2.执行break

嵌套循环

        /*
        嵌套循环
        （开发中通常不会超过3层 3层通常也很少出现）
        嵌套循环的应用
		1. 我们将一个循环结构声明在另一个循环的循环体中 就构成了嵌套循环 这样形成了两个部分（内层循环/外层循环）
		2. 内层循环遍历一遍 则外层循环执行了一次
		3. 外层循环控制行数 内层控制列数/次数
         */

        /*  	i（行号）	j（* 的个数）
        *    	1			1
        **   	2			2
        ****  	3			3
        ***** 	4			4
        ****** 	5			5
         */
        for (int i = 1; i <= 5; i++) {// 控制行数
        	for (int j = 1; j <= i ; j++) {// 控制列数
        		System.out.print("*");
        	}
        	System.out.println();
        }

        /*  	i（行号）	j（* 的个数）    规律：j = 5 - i
        ****    1			4				5
        ***   	2			3				5
        **  	3			2
        *    	4			1
        */
        for (int i = 1; i <= 4; i++) {
       		for (int j = 1; j <= 5 - i; j++) {
       			System.out.print("*");
       		}
       		System.out.println();
        }

        System.out.println();
       /*
	   *
	  * *
	 * * *
	* * * *
	 * * *
	  * *
	   *
	使用" "和"* "组成 分为上下两部分
	上半部分
	行数		" "		"* "
	1		3		1
	2		2		2
	3		1		3
	4		0		4
	" "的个数 = 4 - 行数
	"* "的个数 = 行数

	下半部分
	行数		" "		"* "
	1		1		3
	2		2		2
	3		3		1
	" "的个数 = 行数
	"* "的个数 = 4 - 行数
	在嵌套循环中 当内层循环的列数 = 外层循环的行数 那么 内从循环的列数 <= 外层循环（eg: 行数3 列数3 2 1）
        */
        // 上半部分
        for (int i = 1; i <= 4; i++) {
       		for (int j = 1; j <= 4 - i; j++) {
       			System.out.print(" ");
       		}

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

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

        // 九九乘法表
        for (int i = 1; i <= 9; i++) {
        	for (int j = 1; j <= i; j++) {
        		System.out.print(i + "*" + j + "=" + i * j + "    ");
        	}
        	System.out.println();
        }

break 和 continue 关键字的使用

		/*
		break 和 continue 关键字的使用
		1. 使用范围
		break：switch-case 循环结构
		continue：循环结构
		2. 循环中使用的作用
		break：结束当前循环
		continue：结束当次循环
		关键字后面不能声明执行语句 这两个关键字在这个方面相同
		 */
		for (int i = i; i <= 10; i++) {
			if (i % 4 == 0) {
				break;// 输出结果：123
				// continue;// 输出结果：1235679 10 结束当此循环 开始下一次循环
			}
			System.out.println(i);
		}

		System.out.println();
		/*
		break 默认结束包裹此关键字最近的一层循环（结束本层循环）
		continue 默认结束包裹此关键字最近的一层循环的当此循环 开始下一次循环（结束本次循环）

		带标签的 break 和 continue
		break lable 结束指定标签的循环结构
		ontinue lable 结束指定标签的循环结构的当此循环 开始下一次循环

		return
		并非专门用域结束循环 它的功能是结束一个方法 当一个方法执行到一个 return 语句时 这个方法将被结束（return 结束循环时 直接结束所有层的循环）
		 */
		lable:for (int i = 1; i <= 4; i++) {
			for (int j = 1; j <= 10; j++) {
				if (j % 4 == 0) {
					// break;// break 默认结束包裹此关键字最近的一层循环
					// continue;// continue 默认结束包裹此关键字最近的一层循环的当此循环 开始下一次循环
					// break lable;// 结束指定标签的循环结构
					continue lable;// 结束指定标签的循环结构的当此循环 开始下一次循环
				}
				System.out.println(j);
			}
			System.out.println();
		}