# zb_java0720

**Repository Path**: nuccbw/zb_java0720

## Basic Information

- **Project Name**: zb_java0720
- **Description**: 流程控制
- **Primary Language**: Java
- **License**: MIT
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 8
- **Created**: 2018-07-20
- **Last Updated**: 2021-11-02

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# zb_java0720

# 教学目标
	1.流程控制
# 课堂笔记
## 0 补充：问号表达式[条件判定表达式]
	问号表达式是高级语言中唯一一个三元算运算符：
	语法：
		条件判定表达式?结果表达式1:结果表达式2;
	执行流程：
		（1）执行条件判定表达式，如果条件判定表达式结果为true，则将结果表达式1作为整个问号表达式的结果；
		（2）如果如果条件判定表达式结果为false，则将结果表达式2作为整个问号表达式的结果；
	注意：
		（1）结果表达式1和结果表达式2的类型要一致或兼容【可以默认转换】；
		（2）问好表达式的结果类型取决于结果表达式1和结果表达式2的类型；
		（3）条件判定表达式执行的结果必须是布尔类型；
		（4）条件判定表达式可以嵌套，结果表达式1和结果表达式2可以继续嵌套为条件表达式；
	代码[com.yuw.flow.Test01]:
		```
			/**
	 * 条件表达式
	 */
	private static void test02() {
		// 控制台录入成绩
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的成绩：");
		// 接收输入的值
		int iScore = sc.nextInt();
		String strResult = iScore >= 60 ? "及格" : "不及格";
		System.out.println("你的成绩等级为：" + strResult);
		// 关闭资源
		sc.close();
	}

	/**
	 * 条件表达式
	 */
	private static void test021() {
		// 控制台录入成绩
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的成绩：");
		// 接收输入的值
		int iScore = sc.nextInt();
		String strResult = iScore >= 90 ? "优秀" : 
			iScore >= 80 ? "优良" : 
				iScore >= 70 ? "中等" : 
					iScore >= 60 ? "及格" : "不及格";
		System.out.println("你的成绩等级为：" + strResult);
		// 关闭资源
		sc.close();
	}
		```		
## 1 分支流程
### 1.1 switch语句
	switch语句是多选择分支流程。
	语法：
		switch(匹配表达式){
			case 匹配值1:
				case语句体1；
				break语句；
			case 匹配值2:
				case语句体2；
				break语句；
			case 匹配值n:
				case语句体n；
				break语句；
			default：
				default语句体;	
		}
		
	解析：
		（1）匹配表达式的值和case后面的匹配值做等值匹配（相等运算），
			如果匹配成功，则执行该case块的语句体，如果有break语句，则结束整个switch语句块；执行后续其他代码；
		（2）如果执行的case语句块末尾没有break语句，则会继续执行直到遇到break语句结束或者执行完后续的所有的switch语句；
	注意：
		（1）break语句可有可无；
		（2）如果没有break语句，会从进入的分支一直执行到break语句，或者执行完所有的分支；
		（3）default作用类似于else的作用，default语句一般习惯写在最后，但是也可以写在switch的任何位置；	
			【else只能写在最后】	
		（4）switch后面匹配表达式的结果类型可以是：byte  short  int char String
	代码[com.yuw.flow.Test01]:
		```
	/**
	 * switch多选分支流程
	 */
	private static void test01() {
		// 控制台录入成绩
		Scanner sc = new Scanner(System.in);
		System.out.println("请输入你的成绩：");
		// 接收输入的值
		int iScore = sc.nextInt();
		// 使用switch语句进行程序登记评定
		// iScore/10可以缩减case分支个数，case分支是做等值匹配
		switch (iScore / 10) {
		case 10: // case穿透
		case 9:
			System.out.println("恭喜你，获得优秀等级");
			break;
		case 8:
			System.out.println("恭喜你，获得优良等级");
			break;
		case 7:
			System.out.println("恭喜你，获得中等等级");
			break;
		case 6:
			System.out.println("恭喜你，获得及格等级");
			break;
		default:
			System.out.println("很不幸，没有及格，请继续努力");
		}

		System.out.println("成绩评定结束。");
	}
		```
## 2 循环流程
### 2.1 for循环
	循环流程就是重复执行一段语句块；
	for循环语法：
		for(初始化赋值;循环判定条件;更改循环因子){
			for循环语句体;
		}
	执行流程：
		（1）执行初始化赋值表达式；
		（2）执行循环判定条件表达式，如果为true，则执行for循环语句体；
			如果为false，则结束for循环；执行for循环后续其他代码；
		（3）for循环语句体执行完成之后，执行更改循环因子表达式，转到（2）；
	注意：
		（1）初始化赋值只执行一次，该部分可以为空；【一般是给循环因子赋值】
		（2）循环判定条件表达式执行结果只能布尔类型；该部分可以为空；【for循环继续还是结束判定条件】
		（3）	更改循环因子部分，也可以为空；【一般多用自增、自减表达式】
		（4）以上三部分为空时，分号不能省略；
		（5）注意for的变种形式
		（6）如果for括号中的三部分都不写，则是死循环。
			例如：
			    for(;;){
			    		// 死循环
			    }
		代码[com.yuw.flow.Test01]：	
		```
	/**
	 * for循环：打印1-100之间的奇数
	 */
	private static void test03() {
		// 使用for循环打印1-100之间的奇数
		// 设置一个计数器变量
		int count = 0;
		for (int i = 1; i <= 100; i++) {
			// 判定当前的数是否为奇数
			if (i % 2 == 1) {
				// 输出奇数
				System.out.print(" " + i);
				// 计数器+1
				count++;
				// 如果计数器的个数是10的倍数，则输入出一个换行
				if (count % 10 == 0) {
					System.out.println();
				}
			}
		}
		// 换行
		System.out.println();
	}

	/**
	 * for循环变种形式：打印1-100之间的奇数
	 */
	private static void test031() {
		// 使用for循环打印1-100之间的奇数
		// 设置一个计数器变量
		int count = 0;
		// 初始化写在for循环外边
		int i = 1;
		for (; i <= 100 ;) {
			// 判定当前的数是否为奇数
			if (i % 2 == 1) {
				// 输出奇数
				System.out.print(" " + i);
				// 计数器+1
				count++;
				// 如果计数器的个数是10的倍数，则输入出一个换行
				if (count % 10 == 0) {
					System.out.println();
				}
			}
			// 在循环体的最后，更改循环因子的值
			i++;
		}
		// 换行
		System.out.println();
	}

	/**
	 * for循环-死循环形式：打印1-100之间的奇数
	 */
	private static void test032() {
		// 使用for循环打印1-100之间的奇数
		// 设置一个计数器变量
		int count = 0;
		// 初始化写在for循环外边
		int i = 1;
		for (;;) {
			// 判定当前的数是否为奇数
			if (i % 2 == 1) {
				// 输出奇数
				System.out.print(" " + i);
				// 计数器+1
				count++;
				// 如果计数器的个数是10的倍数，则输入出一个换行
				if (count % 10 == 0) {
					System.out.println();
				}
			}
			// 在循环体的最后，更改循环因子的值
			i++;
		}
		// 换行
		// System.out.println();
	}
		``` 
### 2.2 while循环
	语法：
		while(循环条件判定表达式){
			循环体[改变循环因子的语句];			
		}
	流程：
		（1）执行循环条件判定表达式，如果表达式结果为true，则执行循环体；
			如果结果为false，则结束while循环，继续执行后续其他代码；
		（2）循环体执行完成以后，转（1）。
	注意：
		（1）循环条件判定表达式的结果只能为布尔类型；
		（2）如果循环条件判定表达式的结果恒为true，则是死循环；
		（3）循环体重应该有改变循环因子变量的语句；
		（4）循环因子改变的语句也可以写在循环条件判定表达式中。【主要采用++ -- 表达式】
	代码[com.yuw.flow.Test01]:
		```
				/**
	 * while循环：打印1-100之间的奇数
	 */
	private static void test04() {
		// 变量
		int num = 1;
		// 个数计数器
		int count = 0;
		// while循环遍历1-100，并打印其中的奇数
		while (num <= 100) {
			// 判定当前的数是否为奇数
			if (num % 2 == 1) {
				// 输出奇数
				System.out.print(" " + num);
				// 计数器+1
				count++;
				// 如果计数器的个数是10的倍数，则输入出一个换行
				if (count % 10 == 0) {
					System.out.println();
				}
			}
			// 改变循环因子
			num++;
		}
	}

	/**
	 * while循环：打印1-100之间的奇数
	 */
	private static void test041() {
		// 变量
		int num = 0;
		// 个数计数器
		int count = 0;
		// while循环遍历1-100，并打印其中的奇数
		// 在条件判定表达式中，使用++自增运算改变循环因子的值[注意边界值的处理问题]
		while (num++ < 100) {
			// 判定当前的数是否为奇数
			if (num % 2 == 1) {
				// 输出奇数
				System.out.print(" " + num);
				// 计数器+1
				count++;
				// 如果计数器的个数是10的倍数，则输入出一个换行
				if (count % 10 == 0) {
					System.out.println();
				}
			}
			// 改变循环因子
			// num++;
		}
	}
		```
### 2.2 do-while循环
	语法：
		do{
			do语句体[包含改变循环因子语句];
		}while(循环条件判定表达式);
	流程：
		（1）先执行do语句体；
		（2）执行循环条件判定表达式，如果结果为true，则继续循环执行do语句体；如果为false，则结束do-while循环；
	注意：
		（1）循环条件判定表达式的结果只能为布尔类型；
		（2）如果循环条件判定表达式的结果恒为true，则是死循环；
		（3）循环体重应该有改变循环因子变量的语句；
		（4）循环因子改变的语句也可以写在循环条件判定表达式中。【主要采用++ -- 表达式】
		（5）最后以分号结尾；
	代码[com.yuw.flow.Test01]:
		```
			/**
	 * do-while循环：打印1-100之间的奇数
	 */
	private static void test05() {
		// 变量
		int num = 1;
		// 个数计数器
		int count = 0;
		// do-while循环遍历1-100，并打印其中的奇数
		do {
			// 判定当前的数是否为奇数
			if (num % 2 == 1) {
				// 输出奇数
				System.out.print(" " + num);
				// 计数器+1
				count++;
				// 如果计数器的个数是10的倍数，则输入出一个换行
				if (count % 10 == 0) {
					System.out.println();
				}
			}
			// 改变循环因子
			num++;
		} while (num <= 100);
	}
	/**
	 * do-while循环变形：打印1-100之间的奇数
	 */
	private static void test051() {
		// 变量
		int num = 1;
		// 个数计数器
		int count = 0;
		// do-while循环遍历1-100，并打印其中的奇数
		do {
			// 判定当前的数是否为奇数
			if (num % 2 == 1) {
				// 输出奇数
				System.out.print(" " + num);
				// 计数器+1
				count++;
				// 如果计数器的个数是10的倍数，则输入出一个换行
				if (count % 10 == 0) {
					System.out.println();
				}
			}
			// 改变循环因子
			//num++;
		} while (++num <= 100);
	}
		```
**while循环和do-while循环的区别**
* 1 do-while无论循环判定条件是否成立，do语句体至少会被执行一次；
* 2 while循环只有循环判定条件成立时，才会执行while语句体；

## 3 break和continue关键字
	break和continue关键字是搭配循环使用的；
	另外，break关键字还可以和switch搭配；
	break和continue都是中断处理；
	break和continue的区别：
		break：中断的是其所在的循环体；结束了其所在整个循环体，继续执行后续其他的代码；【循环体结束】
		continue：中断的是当前本次循环；跳过了本次循环的处理流程，直接开始下一次循环，还是在当前循环体中执行；
				【循环体没有结束，结束的是某一次循环】
	代码[com.yuw.flow.Test01]:
	`
		/**
	 * while循环中使用break关键字：打印1-100之间的奇数
	 */
	private static void test061() {
		// 变量
		int num = 0;
		// 个数计数器
		int count = 0;
		// while循环遍历1-100，并打印其中的奇数
		while (true) {
			// 改变循环因子
			num++;
			
			// 使用break作为while循环的结束条件
			if(num > 100){
				// 结束while循环
				break;
			}
			
			// 如果当前数为偶数时，跳过本次循环
			if (num % 2 == 0) {
				continue;
			}
			
			// 当前数为奇数，进行输出
			System.out.print(" " + num);
			// 计数器+1
			count++;
			// 如果计数器的个数是10的倍数，则输入出一个换行
			if (count % 10 == 0) {
				System.out.println();
			}

		}
	}
	
	/**
	 * while循环中使用continue关键字：打印1-100之间的奇数
	 */
	private static void test06() {
		// 变量
		int num = 0;
		// 个数计数器
		int count = 0;
		// while循环遍历1-100，并打印其中的奇数
		while (num < 100) {
			// 改变循环因子
			num++;			
			// 如果当前数为偶数时，跳过本次循环
			if (num % 2 == 0) {
				continue;
			}
			// 当前数为奇数，进行输出
			System.out.print(" " + num);
			// 计数器+1
			count++;
			// 如果计数器的个数是10的倍数，则输入出一个换行
			if (count % 10 == 0) {
				System.out.println();
			}

		}
	}
	`
## 4 多层嵌套循环
	循环中可以嵌套循环；
	多层嵌套循环用于处理多个维度的问题；
	例如：
		两层嵌套循环，一般可以处理2各维度的问题，例如，行和列的关系处理。
	练习：使用*打印一个直角三角形。
	代码[com.yuw.flow.Test01]:
	`
		/**
	 * 练习：使用*打印一个直角三角形。 提示：需要使用两层嵌套循环。
	 */
	private static void test07() {
		// 输入信息
		System.out.println("请输入要打印的直角三角形的行数[大于2的一个正整数]：");
		Scanner sc = new Scanner(System.in);
		// 打印的三角形的行数
		int lines = sc.nextInt();
		// 外层for循环控制行数
		for (int i = 0; i < lines; i++) {
			// 内层for循环控制打印列数
			for (int j = 0; j <= i; j++) {
				System.out.print("*");
			}
			// 换行
			System.out.println();
		}

	}
	`
		
#### 参与贡献

1. Fork 本项目
2. 新建 Feat_xxx 分支
3. 提交代码
4. 新建 Pull Request


#### 码云特技

1. 使用 Readme\_XXX.md 来支持不同的语言，例如 Readme\_en.md, Readme\_zh.md
2. 码云官方博客 [blog.gitee.com](https://blog.gitee.com)
3. 你可以 [https://gitee.com/explore](https://gitee.com/explore) 这个地址来了解码云上的优秀开源项目
4. [GVP](https://gitee.com/gvp) 全称是码云最有价值开源项目，是码云综合评定出的优秀开源项目
5. 码云官方提供的使用手册 [http://git.mydoc.io/](http://git.mydoc.io/)
6. 码云封面人物是一档用来展示码云会员风采的栏目 [https://gitee.com/gitee-stars/](https://gitee.com/gitee-stars/)