程序流程控制介绍
????????在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。
（1）顺序控制
（2）分支控制
（3）循环控制
顺序控制
分支控制 【if-else】?
????????让程序有选择的的执行,分支控制有三种：
（1）单分支 if
（2）双分支 if-else
（3）多分支 if-else if -....-else
单分支
?
双分支?
?
多分支?
多分支的流程图(重要!)?
嵌套分支?
????????在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。建议: 不要超过 3 层 （可读性不好）
?基本语法：
应用案例?
????????参加歌手比赛，如果初赛成绩大于 8.0 进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。?输入成绩和性别，进行判断和输出信息。[NestedIf.java]
import java.util.Scanner;
public class NestedIf {
//编写一个main方法
public static void main(String[] args) {
/*
参加歌手比赛，如果初赛成绩大于8.0进入决赛，
否则提示淘汰。并且根据性别提示进入男子组或女子组。
【可以让学员先练习下】, 输入成绩和性别，进行判断和输出信息。
[NestedIf.java]
提示: double score; char gender;
接收字符: char gender = scanner.next().charAt(0)
*/
//思路分析
//1. 创建Scanner对象，接收用户输入
//2. 接收 成绩保存到 double score
//3. 使用 if-else 判断 如果初赛成绩大于8.0进入决赛，否则提示淘汰
//4. 如果进入到 决赛，再接收 char gender, 使用 if-else 输出信息
//代码实现 => 思路 --> java代码
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入该歌手的成绩");
double score = myScanner.nextDouble();
if( score > 8.0 ) {
System.out.println("请输入性别");
char gender = myScanner.next().charAt(0);
if( gender == '男' ) {
System.out.println("进入男子组");
} else if(gender == '女') {
System.out.println("进入女子组");
} else {
System.out.println("你的性别有误，不能参加决赛~");
}
} else {
System.out.println("sorry ,你被淘汰了~");
}
}
}switch 分支结构
基本语法
流程图：?
switch 注意事项和细节
switch 课堂练习
（1）使用 switch 把小写类型的 char 型转为大写(键盘输入)。只转换 a, b, c, d, e. 其它的输出 "other"。
（2）对学生成绩大于 60 分的，输出"合格"。低于 60 分的，输出"不合格"。(注：输入的成绩不能大于 100)
（3）根据用于指定月份，打印该月份所属的季节。3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季 [课堂练习, 提示 使 用穿透 ]
import java.util.Scanner;
public class SwitchExercise {
//编写一个main方法
public static void main(String[] args) {
//使用 switch 把小写类型的
//char型转为大写(键盘输入)。只转换 a->A, b->B, c, d, e.
//其它的输出 "other"。
//创建Scanner对象
// Scanner myScanner = new Scanner(System.in);
// System.out.println("请输入a-e");
// char c1 = myScanner.next().charAt(0);
// switch(c1) {
// case 'a' :
// System.out.println("A");
// break;
// case 'b' :
// System.out.println("B");
// break;
// case 'c' :
// System.out.println("C");
// break;
// case 'd' :
// System.out.println("D");
// break;
// case 'e' :
// System.out.println("E");
// break;
// default :
// System.out.println("你的输入有误~");
// }
//对学生成绩大于60分的，输出"合格"。低于60分的，
//输出"不合格"。(注：输入的成绩不能大于100), 提示 成绩/60
//思路分析
//1. 这道题，可以使用 分支来完成， 但是要求使用switch
//2. 这里我们需要进行一个转换, 编程思路 :
// 如果成绩在 [60,100] , (int)(成绩/60) = 1
// 如果成绩在 [0,60) , (int)(成绩/60) = 0
//代码实现
double score = 1.1;
//使用if-else 保证输入的成绩有有效的 0-100
if( score >= 0 && score <= 100) {
switch ((int)(score / 60)) {
case 0 :
System.out.println("不合格");
break;
case 1 :
System.out.println("合格");
break;
// default :
// System.out.println("输入有误");
}
} else {
System.out.println("输入的成绩在0-100");
}
//根据用于指定月份，
//打印该月份所属的季节。
//3,4,5 春季 6,7,8 夏季 9,10,11 秋季 12, 1, 2 冬季
//[使用穿透 ]
//
//思路分析
//1. 创建Scanner对象， 接收用户输入
//2. 使用 int month 接收
//3. 使用switch 来匹配 ,使用穿透来完成，比较简洁
Scanner myScanner = new Scanner(System.in);
System.out.println("输入月份");
int month = myScanner.nextInt();
switch(month) {
case 3:
case 4:
case 5:
System.out.println("这是春季");
break;
case 6:
case 7:
case 8:
System.out.println("这是夏季");
break;
case 9:
case 10:
case 11:
System.out.println("这是秋季");
break;
case 1:
case 2:
case 12:
System.out.println("这是冬季");
break;
default :
System.out.println("你输入的月份不对(1-12)");
}
}
}
?switch 和 if 的比较
（1）如果判断的具体数值不多，而且符合 byte、 short 、int、 char, enum[枚举], String 这 6 种类型。虽然两个语句都可以使用，建议使用 swtich 语句
（2）其他情况：对区间判断，对结果为 boolean 类型判断，使用 if，if 的使用范围更广
for 循环控制(!!!)
基本语法?
（1）for 关键字，表示循环控制
（2）for 有四要素: (1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
（3）循环操作 , 这里可以有多条语句，也就是我们要循环执行的代码
（4）如果循环操作(语句) 只有一条语句，可以省略 {}, 建议不要省略
for 循环执行流程分析
注意事项和细节说明?
（1）循环条件是返回一个布尔值的表达式
（2）for(;循环判断条件;) 中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
（3）循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
for 循环练习
（1）打印 1~100 之间所有是 9 的倍数的整数，统计个数及总和.【化繁为简，先死后活！！！】
public class ForExercise {
//编写一个main方法
public static void main(String[] args) {
//打印1~100之间所有是9的倍数的整数，统计个数 及 总和.[化繁为简,先死后活]
//1. 化繁为简 : 即将复杂的需求，拆解成简单的需求，逐步完成
//2. 先死后活 : 先考虑固定的值，然后转成可以灵活变化的值
//
//思路分析
//打印1~100之间所有是9的倍数的整数，统计个数 及 总和
//化繁为简
//(1) 完成 输出 1-100的值
//(2) 在输出的过程中，进行过滤，只输出9的倍数 i % 9 ==0
//(3) 统计个数 定义一个变量 int count = 0; 当 条件满足时 count++;
//(4) 总和 , 定义一个变量 int sum = 0; 当条件满足时累积 sum += i;
//先死后活
//(1) 为了适应更好的需求，把范围的开始的值和结束的值，做出变量
//(2) 还可以更进一步 9 倍数也做成变量 int t = 9;
int count = 0; //统计9的倍数个数 变量
int sum = 0; //总和
int start = 10;
int end = 200;
int t = 5; // 倍数
for(int i = start; i <= end; i++) {
if( i % t == 0) {
System.out.println("i=" + i);
count++;
sum += i;//累积
}
}
System.out.println("count=" + count);
System.out.println("sum=" + sum);
}
}（2）完成下面的表达式输出 【老师评讲 ForExercise02.java】
?
public class ForExercise02 {
//编写一个main方法
public static void main(String[] args) {
//化繁为简
//先死后活
int n = 9;
for( int i = 0; i <= n; i++) {
System.out.println(i + "+" + (n-i) + "=" + n);
}
}
}
while 循环控制
基本语法
流程分析：
?注意事项和细节说明
（1）循环条件是返回一个布尔值的表达式
（2）while 循环是先判断再执行语句
练习题
（1）打印 1—100 之间所有能被 3 整除的数 【使用while循环】
（2）打印 40—200 之间所有的偶数?【使用while循环】
public class WhileExercise {
//编写一个main方法
public static void main(String[] args) {
// 打印1―100之间所有能被3整除的数 [使用while, 老师评讲 ]
// 化繁为简, 先死后活
int i = 1;
int endNum = 100;
while( i <= endNum) {
if( i % 3 == 0) {
System.out.println("i=" + i);
}
i++;//变量自增
}
// 打印40―200之间所有的偶数 [使用while, 课后练习]
// 化繁为简, 先死后活(利于思考)
//
System.out.println("========");
int j = 40; //变量初始化
while ( j <= 200) {
//判断
if( j % 2 == 0) {
System.out.println("j=" + j);
}
j++;//循环变量的迭代
}
}
}do.while 循环控制
基本语法
?细节说明：
（1）do while 是关键
（2）也有循环四要素, 只是位置不一样
（3）先执行，再判断，也就是说，一定会至少执行一次
（4）最后 有一个 分号 ;
流程图
练习：
还钱，如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止?（哈哈，韩老师这个案例太好笑了，印象深刻，大爱老韩~）
import java.util.Scanner;
public class DoWhileExercise02 {
//编写一个main方法
public static void main(String[] args) {
//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为
//[System.out.println("老韩问：还钱吗？y/n")] do...while ..
//
//化繁为简
//(1) 不停的问还钱吗?
//(2) 使用char answer 接收回答, 定义一个Scanner对象
//(3) 在do-while 的while 判断如果是 y 就不在循环
Scanner myScanner = new Scanner(System.in);
char answer = ' ';
do {
System.out.println("老韩使出五连鞭~");
System.out.println("老韩问：还钱吗？y/n");
answer = myScanner.next().charAt(0);
System.out.println("他的回答是" + answer);
}while(answer != 'y');//判断条件很关键
System.out.println("李三还钱了");
}
}多重循环控制(难点! 重点!）
介绍
（1）将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for ,while ,do…while 均可以作为外层循环和内层循环。 【建议一般使用两层，最多不要超过 3 层, 否则，代码的可读性很差】
（2）实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
（3）设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n次。
练习：
【MulForExercise01.java】
（1）统计 3 个班成绩情况，每个班有 5 名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
（2）统计三个班及格人数，每个班有 5 名同学。
import java.util.Scanner;
public class MulForExercise01 {
//编写一个main方法
public static void main(String[] args) {
//统计3个班成绩情况，每个班有5名同学，
//求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
//统计三个班及格人数，每个班有5名同学。
//
//思路分析:
//化繁为简
//(1) 先计算一个班 , 5个学生的成绩和平均分 , 使用for
//1.1 创建 Scanner 对象然后，接收用户输入
//1.2 得到该班级的平均分 , 定义一个 doubel sum 把该班级5个学生的成绩累积
//(2) 统计3个班(每个班5个学生) 平均分
//(3) 所有班级的平均分
//3.1 定义一个变量，double totalScore 累积所有学生的成绩
//3.2 当多重循环结束后，totalScore / (3 * 5)
//(4) 统计三个班及格人数
//4.1 定义变量 int passNum = 0; 当有一个学生成绩>=60, passNum++
//4.2 如果 >= 60 passNum++
//(5) 可以优化[效率，可读性, 结构]
//创建 Scanner 对象
Scanner myScanner = new Scanner(System.in);
double totalScore = 0; //累积所有学生的成绩
int passNum = 0;//累积 及格人数
int classNum = 3; //班级个数
int stuNum = 5;//学生个数
for( int i = 1; i <= classNum; i++) {//i 表示班级
double sum = 0; //一个班级的总分
for( int j = 1; j <= stuNum; j++) {//j 表示学生
System.out.println("请数第"+i+"个班的第"+j+"个学生的成绩");
double score = myScanner.nextDouble();
//当有一个学生成绩>=60, passNum++
if(score >= 60) {
passNum++;
}
sum += score; //累积
System.out.println("成绩为" + score);
}
//因为sum 是 5个学生的总成绩
System.out.println("sum=" + sum + " 平均分=" + (sum / stuNum));
//把 sum 累积到 totalScore
totalScore += sum;
}
System.out.println("三个班总分="+ totalScore
+ " 平均分=" + totalScore / (classNum*stuNum));
System.out.println("及格人数=" + passNum);
}
}?经典的打印金字塔问题
使用 for 循环完成下面的案例，请编写一个程序，可以接收一个整数,表示层数（totalLevel），打印出金字塔。(Stars.java) 【化繁为简, 先死后活】。
?
public class Stars {
//编写一个main方法
public static void main(String[] args) {
/*
*
* *
* *
********
思路分析
化繁为简
1. 先打印一个矩形
*****
*****
*****
*****
*****
2. 打印半个金字塔
* //第1层 有 1个*
** //第2层 有 2个*
*** //第3层 有 3个*
**** //第4层 有 4个*
***** //第5层 有 5个*
3. 打印整个金字塔
* //第1层 有 1个* 2 * 1 -1 有4=(总层数-1)个空格
*** //第2层 有 3个* 2 * 2 -1 有3=(总层数-2)个空格
***** //第3层 有 5个* 2 * 3 -1 有2=(总层数-3)个空格
******* //第4层 有 7个* 2 * 4 -1 有1=(总层数-4)个空格
********* //第5层 有 9个* 2 * 5 -1 有0=(总层数-5)个空格
4. 打印空心的金字塔 [最难的]
* //第1层 有 1个* 当前行的第一个位置是*,最后一个位置也是*
* * //第2层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
* * //第3层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
* * //第4层 有 2个* 当前行的第一个位置是*,最后一个位置也是*
********* //第5层 有 9个* 全部输出*
先死后活
5 层数做成变量 int totalLevel = 5;
*/
int totalLevel = 20; //层数
for(int i = 1; i <= totalLevel; i++) { //i 表示层数
//在输出*之前，还有输出 对应空格 = 总层数-当前层
for(int k = 1; k <= totalLevel - i; k++ ) {
System.out.print(" ");
}
//控制打印每层的*个数
for(int j = 1;j <= 2 * i - 1;j++) {
//当前行的第一个位置是*,最后一个位置也是*, 最后一层全部 *
if(j == 1 || j == 2 * i - 1 || i == totalLevel) {
System.out.print("*");
} else { //其他情况输出空格
System.out.print(" ");
}
}
//每打印完一层的*后，就换行 println本身会换行
System.out.println("");
}
}
}