1. 概要
- 流程控制语句是用来控制程序中各语句执行顺序的语句，可以把语句组合成能完成一定功能的小逻辑模块。
- 其流程控制方式采用结构化程序设计中规定的三种基本流程结构，即：
- 顺序结构：程序从上到下逐行执行，中间没有任何判断和跳转。
- 分支结构：根据条件，选择性地执行某段代码，有if-else和switch-case两种分支语句。
- 循环结构：根据循环条件，重复执行某段代码，有while、do-while、for三种循环语句，JDK1.5提供了foreach循环语句，方便遍历集合、数组元素。
2. 顺序结构
顺序结构的程序设计是最简单的，只要按照解决问题的顺序写出相应的语句就行，它的执行顺序是自上而下，依次执行。
3. 分支结构1：if-else语句
3.1 语法格式
- 第一种：单分支结构
if(条件表达式) {
执行代码块;
}
- 第二种结构：双分支结构，二选一
if(条件表达式) {
执行代码块1;
} else {
执行代码块2;
}
- 第三种：多分支结构，多选一
if(t条件表达式1) {
执行代码块1;
} else if(条件表达式2) {
执行代码块2;
} else if(条件表达式3) {
执行代码块3;
}
...
else {
执行代码块n;
}
3.2 if-else语句使用说明
-
条件表达式运算结果是boolean型的，条件表达式可以是boolean型变量，也可以是boolean型表达式（关系表达式或逻辑表达式）
-
else结构是可选的，根据需要可以省略
-
语句块只有一条语句时，一对{}可以省略，但建议保留
-
根据需要，if-else结构可以嵌套使用
-
当多个条件是“互斥”关系时，条件判断语句及执行语句间的顺序无所谓先后；当多个条件是包含关系时， “小上大下或子上父下 ”，否则被包含的条件就没机会执行了。
代码示例：
/*
岳小鹏参加Java考试，他和父亲岳不群达成承诺：
如果：
成绩为100分时，奖励一辆BMW；
成绩为(80，99]时，奖励一台iphone xs max；
当成绩为[60,80]时，奖励一个 iPad；
其它时，什么奖励也没有。
请从键盘输入岳小鹏的期末成绩，并加以判断
说明：
1. else 结构是可选的。
2. 针对于条件表达式：
> 如果多个条件表达式之间是“互斥”关系(或没有交集的关系),哪个判断和执行语句声明在上面还是下面，无所谓。
> 如果多个条件表达式之间有交集的关系，需要根据实际情况，考虑清楚应该将哪个结构声明在上面。
> 如果多个条件表达式之间有包含的关系，通常情况下，需要将范围小的声明在范围大的上面。否则，范围小的就没机会执行了。
*/
public class IfTest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入岳小鹏期末成绩：(0 -100)");
int score = scanner.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("什么奖励也没有");
}
// 条件包含
if(score == 100) {
System.out.println("奖励一辆BMW");
} else if(score > 80) {
System.out.println("奖励一台iphone xs max");
} else if(score > 60) {
System.out.println("奖励一个 iPad");
}
// else {
// System.out.println("什么奖励也没有");
// }
}
}/*
编写程序：由键盘输入三个整数分别存入变量num1、 num2、 num3，
对它们进行排序(使用 if-else if-else),并且从小到大输出。
说明：
1. if-else结构是可以相互嵌套的。
2. 如果if-else结构中的执行语句只有一行时，对应的一对{}可以省略的。但是，不建议大家省略。
*/
public class IfTest2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入第一个整数：");
int num1 = scanner.nextInt();
System.out.println("请输入第二个整数：");
int num2 = scanner.nextInt();
System.out.println("请输入第三个整数：");
int num3 = scanner.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) {
/*
在Java语言中,在if-else语句没有括号的情况下,if和else的匹配采用就近原则,
即else总是与离它最近的if进行配对。
输出结果为：x is 4
*/
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);
//课后练习3：测算狗的年龄
int dogAge = 6;
if(dogAge >= 0 && dogAge <= 2){
System.out.println("相当于人的年龄：" + dogAge * 10.5);
}else if( dogAge > 2){
System.out.println("相当于人的年龄：" + (2 * 10.5 + (dogAge - 2) * 4));
}else{
System.out.println("狗狗还没出生呢！");
}
//课后练习4：如何获取一个随机数：10 - 99
// [0.0,1.0) --> [0.0,90.0) --->[10.0, 100.0) -->[10,99]
int value = (int)(Math.random() * 90 + 10);
System.out.println(value);
//公式：[a,b] : (int)(Math.random() * (b - a + 1) )+ a
}
}4. 分支结构2：switch-case语句
4.1 语法格式
switch(表达式) {
case 常量1：
语句块1;
break;
case 常量2：
语句块1;
break;
... ...
case 常量n：
语句块n;
break;
default:
语句块n+1;
//break;
}执行流程图：
4.2 switch-case语句使用说明
- switch(表达式)中表达式的值必须是下述6种类型之一：byte，short，int，char，枚举(JDK5.0)，String(JDK7.0)。
- case子句中的值必须是常量，不能是变量或不确定的表达式值。
- 同一个switch语句，所有case子句中的常量互不相同。
- default子句是可选的，同时位置也是灵活的，但建议声明在最后一个。
- 根据switch表达式的值，依次匹配各个case子句中的常量。一旦匹配成功，则会进入相应case子句中，并执行其语句，如果没有遇到break关键字，则仍然会继续向下执行其它case子句中的执行语句，直到遇到break关键字或此switch-case结构结尾为止。如果没有匹配成功，且存在default子句时，则执行default子句中的语句。
- break关键字是可选的，可以使用在switch-case结构中，表示一旦执行到此关键字，就跳出switch-case结构。
代码示例：
/*
对学生成绩大于60分的，输出“合格”。低于60分的，输出“不合格” 。
*/
public class SwitchCaseTest1 {
public static void main(String[] args) {
int score = 78;
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("及格");
}
}
}/*
从键盘分别输入年、月、日，判断这一天是当年的第几天
注：判断一年是否是闰年的标准：
1）可以被4整除，但不可被100整除
或
2）可以被400整除
*/
public class SwitchCaseTest2 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.println("请输入year：");
int year = scanner.nextInt();
System.out.println("请输入month：");
int month = scanner.nextInt();
System.out.println("请输入day：");
int day = scanner.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 += (year % 4 == 0 && year % 100 != 0) ||year % 400 == 0 ? 29 : 28;
case 2:
sumDays += 31;
case 1:
sumDays += day;
}
System.out.println(year + "年" + month + "月" + day + "日" + "是当年的第" + sumDays + "天");
}
}5. 循环结构1：for循环
- 循环结构的4个要素
①初始化部分：用于初始化循环控制变量，即初始化循环计数器
②循环条件判断部分：用于判断循环是否继续执行
③循环体部分：循环期间会重复执行的代码块
④迭代器部分：用于更新循环控制变量的值，即更新循环计数器
- 语法格式
for(①初始化; ②循环条件判断; ④迭代器) {
③循环体代码;
}- 执行过程
①-②-③-④-②-③-④-②-③-④-......-②
- 使用说明
- ②循环条件判断部分为boolean类型表达式，当值为false时，退出循环。
- ①初始化部分可以声明多个变量，但必须是同一种类型，用逗号分隔
- ④迭代器部分可以有多个变量更新，逗号分隔
代码示例：
public class ForTest1 {
public static void main(String[] args) {
// 练习：
int num = 1;
for(System.out.print('a');num <=3; System.out.print('c'), num++) {
System.out.print('b');
}
//例题：遍历100以内的偶数
int sum = 0;
for(int index = 0; index <= 100; index++) {
if(index % 2 == 0) {
System.out.println(index);
sum += index;
}
}
System.out.println(sum);
}
}6. 循环结构2：while循环
- 语法格式
①初始化;
while(②循环条件判断) {
③循环体;
④迭代器;
}- 执行过程
①-②-③-④-②-③-④-②-③-④-......-②
- 使用说明
- 注意不要忘记声明④迭代器部分，否则，循环将不能结束，变成死循环。
- for循环和while循环可以互相转换
7. 循环结构3：do-while循环
- 语法格式
①初始化;
do {
③循环体;
④迭代器;
} while(②循环条件判断);- 执行过程
①-③-④-②-③-④-②-③-④-②-......-②
- 使用说明
do-while循环至少执行一次循环体。
8. 特殊关键字的使用：break、continue
- 无限循环
-
最简单的无限循环格式：for(;;)，while(true)
-
无限循环存在的原因：无法确定循环的次数，需要根据循环体内部某些条件来控制循环的结束。
/*
从键盘读入个数不确定的整数，
并判断读入的正数和负数的个数，
输入为0时结束程序。
*/
public class InfiniteLoopTest {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int positiveNumber = 0;
int negativeNumber = 0;
while (true) {
int num = scanner.nextInt();
if(num > 0) {
positiveNumber++;
} else if (num < 0) {
negativeNumber++;
} else {
break;
}
}
System.out.println("正数个数为：" + positiveNumber);
System.out.println("负数个数为：" + negativeNumber);
}
}- 嵌套循环
将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for，while，do-while均可以作为 外层循环或内层循环。
/*
嵌套循环的使用
1、定义：将一个循环结构A声明在另外一个循环结构B的循环体中，就构成了嵌套循环
外层循环：循环结构B
内层循环：循环结构A
2、说明：
① 内层循环结构遍历一遍，只相当于外层循环结构的循环体只执行了一次
② 假设外层循环需要执行m次，内层循环需要执行n次，此时内层循环的循环体一共执行了m * n次
3、技巧
外层循环控制行数，内层循环控制列数
*/
public class ForForTest {
public static void main(String[] args) {
/*
打印以下图形：
*
**
***
****
*****
*/
for (int i = 1; i <= 5; i++) {
for(int j = 1; j <= i; j++) {
System.out.print("*");
}
System.out.println();
}
/*
打印以下图形：
*****
****
***
**
*
*/
for(int i = 1; i <= 5; i++) {
for(int j = 1; j <= 6 - i; j++ ) {
System.out.print('*');
}
System.out.println();
}
/*
*
* *
* * *
* * * *
* * * * *
* * * *
* * *
* *
*
*/
//上半部分
for(int i = 1; i <= 5; i++) {
for(int j = 1; j <= 5 - i; j++ ) {
System.out.print(" ");
}
for(int j = 1; j <= i; j++) {
if(j < i) {
System.out.print("* ");
}else {
System.out.print("*");
}
}
System.out.println();
}
//下半部分
for(int i = 1; i <= 4; i++) {
for(int j = 1; j <= i; j++ ) {
System.out.print(" ");
}
for(int j = 1; j <= 5 - i; j++) {
System.out.print("*");
if(j < 5 - i) {
System.out.print(" ");
}
}
System.out.println();
}
/*
九九乘法表
1 * 1 = 1
2 * 1 = 2 2 * 2 = 4
...
9 * 1 = 9 9 * 2 = 18 ... 9 * 9 = 81
*/
for(int i= 1; i <= 9; i++ ) {
for(int j = 1; j <= i; j++) {
System.out.print(i + " * " + j + " = " + (i * j));
if(j < i) {
System.out.print(" ");
}
}
System.out.println();
}
/*
输出100以内的质数
质数：素数，只能被1和它本身整除的自然数 -> 从2开始，到这个数 - 1为止，都不能被这个数本身整除
*/
boolean isFlag = true; // 默认i为质数
for(int i = 2; i <= 100; i++) {
// 优化二：对本身为质数的自然数是有效的
// for(int j = 2; j < i; j++){
for(int j = 2; j <= Math.sqrt(i); j++) {
if(i % j == 0) { // i能被j整除，则i不是质数
isFlag = false;
break; //优化一：只对本身为非质数的自然数有效
}
}
// 输出质数
if(isFlag) {
System.out.println(i);
}
// 重置isFlag
isFlag = true;
}
}
}- break和continue关键字使用说明
- break只能用于switch-case语句和循环语句中
- continue只能用于循环语句中
- 二者功能类似，但continue是终止本次循环，break是终止本层循环，循环结构默认是包裹关键字最近的一层循环
- break、continue之后不能声明其它语句，因为程序永远不会执行其后的语句。
- break、continue出现在多层嵌套的循环语句中时，可以通过标签指明要终止/跳过的是哪一层循环，标签必须紧接在循环头部
/*
break和continue关键字的使用
使用范围 循环中使用的作用(不同点) 相同点
break: switch-case
循环结构中 结束当前循环 关键字后面不能声明执行语句
continue: 循环结构中 结束当次循环 关键字后面不能声明执行语句
*/
public class BreakContinueTest {
public static void main(String[] args) {
for(int i = 1; i <= 10; i++) {
if(i % 4 == 0) {
break; // 123
//continue; // 123567910
}
System.out.print(i);
}
label:for(int i = 1; i <= 4; i++) {
for (int j = 1; j <= 10; j++) {
if(j % 4 == 0){
//break; //默认跳出包裹此关键字最近的一层循环
//continue;
//break label; // 结束指定标识的一层循环结构
continue label; // 结束指定标识的一层循环结构的当次循环
}
System.out.print(j);
}
System.out.println();
}
}
}- return关键字
return关键字并非专门用于结束循环的，它的功能是结束一个方法，当一个方法执行到return关键字时，这个方法将被结束，不管renturn关键字处于多少层循环内。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
