2.5、程序流程控制
- 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
- 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
① 顺序结构
② 分支结构
③ 循环结构
**顺序结构：**程序从上到下逐行执行，中间没有任何判断和跳转。
**分支结构：**根据条件，选择性地执行某段代码，有if-else和switch-case两种分支语句。
**循环结构：**根据循环条件，重复性的执行某段代码。有while、do-while、for三种循环语句。注：JDK1.5提供了foreach循环，方便的遍历集合、数组元素。
2.5.1、顺序结构
Java中定义成员变量时采用合法的前向引用。如：
public class Test{
int num1 = 12;
int num2 = num1 + 2;
}
错误形式：
public class Test{
int num2 = num1 + 2;
int num1 = 12;
}
2.5.2、分支语句1：if-else结构
if 语句的三种格式：
分支结构：if-else使用说明
- 条件表达式必须是布尔表达式（关系表达式或逻辑表达式）、布尔变量
- 语句块只有一条执行语句时，一对{}可以省略，但建议保留
- if-else语句结构，根据需要可以嵌套使用
- 当if-else结构是“多选一”时，最后的else时可选的，根据需要可以省略
- 当多个条件是“互斥”关系时，条件判断语句以及执行语句间顺序无所谓，当多个条件时“包含”关系时，“小上大下/子上父下”
/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断
说明：
1.else结构是可选的。
2.针对于条件表达式：
如果多个条件表达式之间是“互斥”关系（或没有交集的关系），
哪个判断和执行语句声明在上面还是下面无所谓。
如果多个条件表达式之间有交集的关系，需要根据实际情况，
考虑清楚应该将哪个结构声明在上面。
如果多个条件表达式之间有包含的关系，通常情况下，需要
将范围小的生命在范围大的上面，否则，范围小的就没机会
执行了。
*/
import java.util.Scanner;
class IfTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入岳小鹏的期末成绩：（0-100）");
int score = scan.nextInt();
if(score == 100){
System.out.println("奖励一辆BMW");
} else if (score > 80 && score <=99){
System.out.println("奖励一台iphone xs max");
} else if (score >= 60 && score <= 80){
System.out.println("奖励一台ipad");
} else {
System.out.println("没有奖励！");
}
}
}
/*
编写程序：由键盘输入三个整数分别存入变量num1、num2、num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。
说明：
1.if-else结构是可以相互嵌套的
2.如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略，但是！不建议大家省略！
*/
import java.util.Scanner;
class IfTest2{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int num1 = scan.nextInt();
System.out.println("请输入第二个整数：");
int num2 = scan.nextInt();
System.out.println("请输入第三个整数：");
int num3 = scan.nextInt();
if(num1 > num2){
if(num3 > num1){
System.out.println(num2 + "," + num1 + "," + num3);
} else if(num3 < num2){
System.out.println(num3 + "," + num2 + "," + num1);
} else {
System.out.println(num2 + "," + num3 + "," + num1);
}
} else {
if(num3 > num2){
System.out.println(num1 + "," + num2 + "," + num3);
} else if(num3 < num1){
System.out.println(num3 + "," + num1 + "," + num2);
} else{
System.out.println(num1 + "," + num3 + "," + num2);
}
}
}
}
class IfExer{
public static void main(String[] args){
int x = 4;
int y = 1;
if (x > 2)
if (y > 2)
System.out.println(x + y);
//System.out.println("atguigu");
else//就近原则
System.out.println("x is " + x);//这个是输出结果
}
}
/*
大家都知道，男大当婚，女大当嫁。那么女方家长要嫁女儿，当然要提出
一定的条件：高：180cm以上；富：财富1千万以上；帅：是。
1.如果这三个条件同时满足，则：“我一定要嫁给他!!!”
2. 如果三个条件有为真的情况，则：“嫁吧，比上不足，比下有余。”
3.如果三个条件都不满足，则：“不嫁！”
*/
import java.util.Scanner;
class IfExer1{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入身高：");
int height = scan.nextInt();
System.out.println("请输入财富（千万）：");
double money = scan.nextDouble();
System.out.println("请输入是否帅：（true/false）");
boolean isCool = scan.nextBoolean();
if(height >= 180 && money >= 1 && isCool){
System.out.println("一定嫁！");
} else if(height >= 180 || money >= 1 || isCool){
System.out.println("嫁吧~");
} else {
System.out.println("不嫁！");
}
}
}
2.5.3、分支语句2：switch-case结构
/*
分支结构之二：switch-case
1.格式：
switch（表达式）{
case 常量1：
执行语句1；
//break；
case 常量2：
执行语句2；
//break；
……
default:
执行语句n；
//break；
}
2.说明：
① 根据switch表达式中的值，依次匹配各个case中的
常量，一旦匹配成功，则进入相应case结构中，调用
其执行语句。当调用完执行语句以后，则任然继续向下
执行其他case结构中的执行语句，直到遇到break关键字
或此switch-case结构末尾结束为止。
② break，可以使用在switch-case结构中，表示一旦
执行到此关键字，就跳出switch-case结构。
③ switch结构中的表达式只能是如下的六种数据类型之一：
byte、short、char、int、枚举类型(JDK5.0新增)、String类型(JDK7.0新增)
④ case 之后只能声明常量，不能声明范围。
⑤ break关键字是可选的，根据实际需求添加。
⑥ default关键字相当于if-else结构中的else。default结构是可选的，而且位置是灵活的。
*/
class SwitchCaseTest{
public static void main(String[] args){
int number = 2;
switch(number){
case 0:
System.out.println("zero");
break;
case 1:
System.out.println("one");
break;
case 2:
System.out.println("two");
break;
case 3:
System.out.println("three");
break;
default:
System.out.println("other");
}
String season = "summer";
switch (season) {
case "spring":
System.out.println("春暖花开");
break;
case "summer":
System.out.println("夏日炎炎");
break;
case "autumn":
System.out.println("秋高气爽");
break;
case "winter":
System.out.println("冬雪皑皑");
break;
default:
System.out.println("季节输入有误");
break;
}
//*************以下两种情况编译不通过*******************
/*boolean isHandsom = true;
switch(isHandsom){
case true:
System.out.println("我很帅！");
break;
case false:
System.out.println("我很丑！");
break;
default:
System.out.println("输入有误！");
}*/
/*int age = 10;
switch(age){
case age>=18:
System.out.println("成年了！");
break;
case age<18:
System.out.println("未成年！");
break;
default:
System.out.println("输入有误！");
}*/
}
}
switch语句有关规则
- switch(表达式)中表达式的值必须是下述几种类型之一：byte、short、char、int、枚举（JDK5.0）、String（JDK7.0）
- case子句中的值必须是常量，不能是变量名或不确定的表达式值
- 同一个switch语句，所有case子句中的常量值互不相同
- break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有break语句，程序会顺序执行到switch结尾
- default子句是可任选的，同时，位置也是灵活的，当没有匹配的case时，执行default
/*
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格”。
说明：
如果switch-case结构中的多个case的执行语句相同，则可以进行合并。
*/
class SwitchCaseTest1{
public static void main(String[] args){
int score = 78;
//这种方法不靠谱
/*switch(score){
case 0:
case 1:
case 2:
……
case 100:
}*/
switch(score/10){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("不及格");
break;
case 2:
System.out.println("不及格");
break;
case 3:
System.out.println("不及格");
break;
case 4:
System.out.println("不及格");
break;
case 5:
System.out.println("不及格");
break;
case 6:
System.out.println("及格");
break;
case 7:
System.out.println("及格");
break;
case 8:
System.out.println("及格");
break;
case 9:
System.out.println("及格");
break;
case 10:
System.out.println("及格");
break;
}
//对以上代码进行改写
switch(score/10){
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
System.out.println("不及格");
break;
case 6:
case 7:
case 8:
case 9:
case 10:
System.out.println("及格");
break;
}
switch(score/60){
case 0:
System.out.println("不及格");
break;
case 1:
System.out.println("及格");
break;
}
}
}
/*
编写程序：从键盘上输入2019年的“month”和“day”，要求通过程序
输出输入的日期为2019年的第几天。
说明：break在switch-case结构中是可选的。
*/
import java.util.Scanner;
class SwitchCaseTest2{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入2019年的month：");
int month = scan.nextInt();
System.out.println("请输入2019年的day：");
int day = scan.nextInt();
//定义一个变量来保存总天数
int sumDays = 0;
//方式一：代码冗余，不推荐
/*if(month == 1){
sumDays = day;
} else if(month == 2){
sumDays = 31 + day;
} else if(month == 3){
sumDays = 31 + 28 + day;
} else if(month == 4){
sumDays = 31 +28 + 31 + day;
}
//……
else{
sumDays = …… + day;
}*/
//方式二：冗余
/*switch(month){
case 1:
sumDays = day;
break;
case 2:
sumDays = 31 + day;
break;
case 3:
sumDays = 31 + 28 + day;
break;
...
}*/
switch(month){
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
sumDays += 28;
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println(month + "月" + day + "号" + "是2019年的第" + sumDays + "天");
}
}
/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或
2）可以被400整除
说明：
1.凡是可以使用switch-case的结构，都可以转换为if-else，反之不成立
2.当我们写分支结构时，发现既可以使用switch-case又可以使用if-else
结构时（switch中的case取值情况不多），优先选择使用switch-case结构。
原因：switch-case相比于if-else结构效率稍微高一点。
*/
import java.util.Scanner;
class SwitchCaseExer{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入year：");
int year = scan.nextInt();
System.out.println("请输入month：");
int month = scan.nextInt();
System.out.println("请输入day：");
int day = scan.nextInt();
//定义一个变量来保存总天数
int sumDays = 0;
switch(month){
case 12:
sumDays += 30;
case 11:
sumDays += 31;
case 10:
sumDays += 30;
case 9:
sumDays += 31;
case 8:
sumDays += 31;
case 7:
sumDays += 30;
case 6:
sumDays += 31;
case 5:
sumDays += 30;
case 4:
sumDays += 31;
case 3:
//sumDays += 28;
//判断闰年
if((year%4==0 && year%100!=0) || (year%400==0)){
sumDays += 29;
} else {
sumDays += 28;
}
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println(year + "年" + month + "月" + day + "号" + "是2019年的第" + sumDays + "天");
}
}
switch和if语句的对比
if和switch语句很像，具体什么场景下应用哪个语句呢？
① 如果判断的具体数值不多，而且符合byte、short、char、int、String、枚举等几种类型。虽然两个语句都可以使用，建议使用switch语句，因为效率稍高。
② 其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广。也就是说，使用switch-case的都可以改写为if-else，反之不成立。
2.5.4、循环结构
- 循环结构
在某些条件满足的情况下，反复执行特定代码的功能 - 循环语句分类
for循环、while循环、do-while循环 - 循环语句的四个组成部分
① 初始化部分（init_statement）
② 循环条件部分（test_exp）
③ 循环体部分（body_statement）
④ 迭代部分（alter_statement）
循环结构1：for循环
- 语法格式
for(①初始化部分; ②循环条件部分; ④迭代部分){
③循环体部分;
} - 执行过程
①–②--③–④--②–③--④–……–② - 说明：
②循环条件部分为boolean类型表达式当值为false时，退出循环
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
④可以有多个变量更新，用逗号分隔
/*
For循环结构的使用
一、循环结构的4个要素
① 初始化条件
② 循环条件----->boolean类型
③ 循环体
④ 迭代条件
二、for循环的结构
for(①；②；④){
③
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ -……- ②
*/
class ForTest{
public static void main(String[] args){
for(int i=1; i<=5; i++){
System.out.println("Hello For循环！");
}
//i在for循环内有效，出了for循环就失效了
//练习：
int num = 1;
for(System.out.print('a'); num<=3; System.out.print('c'),num++){
System.out.print('b');
}
//输出结果：abcbcbc
System.out.println();
//练习二：遍历100以内的偶数
int sum = 0;//记录所有偶数的和
int count = 0;//记录偶数的个数
for(int i=1; i<=100; i++){
if(i%2==0){
System.out.println(i);
sum += i;
count++;
}
//System.out.println("总和为： " + sum);
}
System.out.println("总和为： " + sum);
System.out.println("偶数个数为： " + count);
}
}
/*
编写程序从1循环到150，并在每行打印一个值，另外在每个3的倍数行上打印出“foo”,
在每个5的倍数行上打印“biz”,在每个7的倍数行上打印输出“baz”。
*/
class ForTest1{
public static void main(String[] args){
for(int i=1; i<=150; i++){
System.out.print(i + " ");
if(i%3==0){
System.out.print("foo ");
}
if(i%5==0){
System.out.print("biz ");
}
if(i%7==0){
System.out.print("baz ");
}
System.out.println();
}
}
}
/*
题目：输入两个正整数m和n，求其最大公约数和最小公倍数。
比如：12和20的最大公约数是4，最小公倍数是60.
说明：break关键字的使用：在循环中一旦遇到break就跳出循环。
*/
import java.util.Scanner;
class ForTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请输入第一个正整数：");
int m = scan.nextInt();
System.out.println("请输入第二个正整数：");
int n = scan.nextInt();
//获取最大公约数
//获取两个数中的较小值
int min = (m > n)? n : m;
for(int i = min; i >= 1; i--){
if(m%i==0 && n%i==0){
System.out.println(m + "和" + n + "的最大公约数是：" + i);
break;
}
}
//获取最小公倍数
//获取两个数中的较大值
int max = (m > n)? m : n;
for(int i = max; i <= m*n; i++){
if(i%m==0 && i%n==0){
System.out.println(m + "和" + n + "的最小公倍数是：" + i);
break;
}
}
}
}
循环结构2：while循环
- 语法格式
①初始化部分
while(②循环条件部分){
③循环体部分;
④迭代部分;
} - 执行过程
① - ② - ③ - ④ - ② - ③ - ④ - …… - ②
说明：- 注意不要忘记声明④迭代部分。否则，循环将不能结束，变成死循环。
- for循环和while循环可以互相转换
/*
While循环的使用
一、循环的四个要素
①初始化条件
②循环条件---->是boolean类型
③循环体
④迭代条件
二、while循环的结构
①
while(②){
③;
④;
}
执行过程：① - ② - ③ - ④ - ② - ③ - ④ - …… - ②
说明：
1.写while循环千万要小心不要丢了迭代条件，一旦丢了，就可能导致死循环。
2.我们写程序，要避免出现死循环。
3.for循环和while循环是可以相互转换的。
区别：for循环和while循环的初始化条件部分的作用范围不同。
算法：有限性。
*/
class WhileTest{
public static void main(String[] args){
//遍历100以内的所有偶数
int i = 1;
while(i <= 100){
if(i%2 == 0){
System.out.println(i);
}
i++;
}
//i 出了while循环仍可以调用
System.out.println(i);
}
}
循环结构3：do-while循环
- 语法格式
①初始化部分;
do{
③循环体部分
④迭代部分
}while(②循环条件部分) - 执行过程
① - ③ - ④ - ② - ③ - ④ - ② - ③ - ④ - …… - ②
/*
do-while循环的使用
一、循环的四个要素
①初始化条件
②循环条件---->是boolean类型
③循环体
④迭代条件
二、do-while循环结构：
①
do{
③;
④;
}while(②);
执行过程：① - ③ - ④ - ② - ③ - ④ - …… - ②
说明：
1.do-while循环至少会执行一次循环体。
2.在开发中，使用for和while更多一些，较少使用do-while
*/
class DoWhileTest{
public static void main(String[] args){
//遍历100以内的偶数，并计算所有偶数的和及偶数的个数
int num = 1;
int sum = 0;
int count = 0;
do{
if(num%2 == 0){
System.out.println(num);
sum += num;
count++;
}
num++;
}while(num<=100);
System.out.println("总和为：" + sum);
System.out.println("总个数为：" + count);
System.out.println("*******体会do-while执行至少执行一次******");
int number = 10;
while(number>10){
System.out.println("while");
number++;
}
do{
System.out.println("do-while");
}while(number>10);
}
}
循环语句综合例题
/*
从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入
为0时结束程序。
最简单“无限” 循环格式：while(true) , for(;;),无限循环存在的原因是并不
知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。
说明：
1.不在循环条件部分限制次数的结构：for(;;) 或 while(true)
2.结束循环有几种方式？
方式一：循环条件部分返回false
方式二：在循环体中执行break
*/
import java.util.Scanner;
class ForWhileTest{
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("请随机输入一组正负数：");
int positiveNum = 0;//记录正数个数
int negativeNum = 0;//记录负数个数
for(;;){//while(true){
int num = scan.nextInt();
if(num > 0){
positiveNum++;
} else if(num < 0){
negativeNum++;
} else {
break;//跳出循环
}
}
System.out.println("正数个数：" + positiveNum);
System.out.println("负数个数：" + negativeNum);
}
}
最简单“无限” 循环格式：while(true) , for（;;）,无限循环存在的原因是并不知道循环多少次，需要根据循环体内部某些条件，来控制循环的结束。
2.5.7、嵌套循环（多重循环）
- 将一个循环放在另一个循环体内，就形成了嵌套循环。其中for、while、do-while均可以作为外层循环或内层循环。
- 实质上，嵌套循环就是把内层循环当成外层循环的循环体，当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环。
- 设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。
/*
九九乘法表
1*1=1
2*1=2 2*2=4
3*1=3 2*3=6 3*3=9
......
9*1=9 ...... 9*9=81
*/
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 + " ");
}
System.out.println();
}
}
}
/*
100000以内所有质数的输出 实现方式二
质数：即素数，只能被1和它本身整除的自然数。
--->从2开始到这个数结束位置，都不能被这个数本身整除。
最小的质数是：2
对PrimeNumberTest.java代码的优化
*/
class PrimeNumberTest2{
public static void main(String[] args){
int count = 0;
long start = System.currentTimeMillis();
lable:for(int i=2; i<=100000; i++){//遍历100000以内的自然数
//boolean isFlag = true;//标识i是否被j除尽过，一旦除尽，修改其值
//优化二：对本身是质数的自然数是有效的。
//for(int j=2; j<i; j++){
for(int j=2; j<=Math.sqrt(i); j++){//j：被i去除
if(i%j == 0){//i被j除尽
continue lable;
}
}
//能执行到此步骤的，都是质数
count++;
}
long end = System.currentTimeMillis();
System.out.println("质数的个数：" + count);
System.out.println("程序执行时间：" + (end - start));
}
}
2.5.8、特殊关键字的使用：break、continue
- break语句
- break语句用于终止某个语句块的执行
{ ……
break;
……
} - break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块
- break语句用于终止某个语句块的执行
- continue语句
- continue只能使用在循环结构中
- continue语句用于跳过其所在循环语句块的一次执行，继续下一次循环
- continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环
- return语句
- 并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内。
- 特殊流程控制语句说明
- break只能用于switch语句和循环语句中。
- continue只能用于循环语句中。
- 二者功能类似，但continue是终止本次循环，break是终止本层循环。
- break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
- 标号语句必须紧接在循环的头部，标号语句不能用在非循环语句的前面。
- 很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的。
22万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
