第五章、控制语句

最新推荐文章于 2024-06-17 08:55:14 发布

墨染年华ら

最新推荐文章于 2024-06-17 08:55:14 发布

阅读量1k

点赞数 23

分类专栏：重学JavaSE j2se 文章标签： java

本文链接：https://blog.csdn.net/Calvex880714/article/details/135047418

版权

j2se 同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

重学JavaSE

5 篇文章 0 订阅

订阅专栏

3、if-else-if-else语句：多分支条件判断

4、嵌套if--else

5、switch语句

6、if-else语句与switch语句的比较

一、前言

流程控制语句，是根据程序的状态变化，引导程序的执行流程与分支。java程序控制语句主要分为选择、迭代(循环)、和跳转语句

选择语句：允许程序根据条件表达式的输出结果(true或false)或变量的状态，选择程序不同的执行路径，包括if、switch语句

迭代(循环)语句：可以使程序逻辑重复执行一条或多条语句，直到起控制作用布尔表达式结果变为false，循环即结束。包括while、do-while、for

跳转语句：使程序能够以非线性的方式来执行。包括break、continue和return

二、选择语句

1、if语句：单分支条件判断

1)、语法格式：

if(条件表达式){
    statement1语句块;
}

2)、说明： 条件表达式必须是布尔表达式(关系表达式或逻辑表达式)或布尔变量

3)、执行流程：

首先判断条件表达式看其结果是 true 还是 false
如果是 true 就执行语句块
如果是 false 就不执行语句块

4)、应用举例：

int heartBeats = 89;
if(heartBeats < 60 || heartBeats > 100){
    System.out.println("需要进一步检查");
}

2、if-else语句：双分支条件判断

1)、语法格式：

if(条件表达式){
    statement1语句块;
}else{
    statement2语句块;
}

2)、说明：条件表达式必须是布尔表达式(关系表达式或逻辑表达式)或布尔变量

3)、执行流程：

首先判断条件表达式看其结果是 true 还是 false
若条件表达式返回为true，则执行statement1语句块，
若条件表达式返回false，则执行statement2语句块。

4)、应用举例：

//判断一个数是奇数还是偶数
int count = 15;
if(count%2==0){
    System.out.println("这是一个奇数");
}else{
    System.out.println("这是一个偶数");
}

3、if-else-if-else语句：多分支条件判断

1)、语法格式：

if (条件表达式1) {
    statement1语句块;
} else if (条件表达式2) {
    statement2语句块;
}
.......
}else if(条件表达式n){
    statement(n)语句块;
}else{
    statement(n+1)语句块;
}

2)、说明：当某个条件表达式为 true，则进入执行相应的语句块。执行完对应的语句块之后，则跳出当前结构

3)、执行流程：

首先执行条件表达式1 ，判断其结果是true还是false
若结果为true，则执行语句块 1，结束当前多分支
若结果为false，则执行条件表达式2 ，判断其结果是true还是false
若结果为true，则执行语句块 2，结束当前多分支
若结果为false，则继续判断其他条件表达式，判断其结果是true还是false
若后续的条件表达式都返回fasle，则执行语句块 n+1，结束当前多分支。

int score = 80;
if(score == 100){
    System.out.println("优秀");
}else if(score > 80 && score <= 99){ 
    System.out.println("良好");
}else if(score >= 60 && score <= 80){
    System.out.println("合格");
} else{
    System.out.println("不合格");
}

特别提醒：语句块可以是单条语句，也可以是复合语句，如果语句块是单条语句，那么{}可以省略，若是符合语句，则不可省略。为了程序的可读性，建议不管何种情况不要省略{}。如：

int byteAvailable;
int a = 0;
if(a>0){
    statement1;
}else
    statement1;
    byteAvailable =10;

该代码块中else部分未加{}括号，其中 byteAvailable=10语句的边界则不清楚，该语句是在else内还是在esle外。在该段程序执行时，系统则会判定为在else以外的独立语句块。

4、嵌套if--else

1)、语法格式：

if(条件表达式){
    if(条件表达式1){
        statement语句块1
    }else if(条件表达式2){
        statement语句块2
    }else {
        statement语句块3
    }
}else {
    statement语句块4
}

2)、说明：在 if 的语句块中，或者是在 else 语句块中，再包含了另外一个条件判断(可以是单分支、双分支或多分支)，这样就形成了if嵌套结构

3)、执行流程：

如果是嵌套在 if 语句块中的，只有当外部的条件表达式结果为true，才会进行内部的条件表达式判断
如果是嵌套在 else 语句块中，只有当外部的条件表达式结果为false，才会进入else内部的条件表达式判断

注意：在if嵌套语句中，else语句总是与位于同一代码块中最近的if语句相关联，作为其else子句。

5、switch语句

1)、语法格式：

switch(表达式值){
    case 常量值 1:
        语句块 1;
        break;
    case 常量值 2:
        语句块 2;
        break;
         ...
    default:
        语句块 n+1;
        break;
}

2)、说明：

switch(表达式)中表达式的值在JDK1.7以下版本中必须是byte，short，char，int，枚举，在JDK1.7版本时增加了 String类型；
case 子句中的值必须是常量，不能是变量名或不确定的表达式值或范围；
同一个 switch 语句，所有 case 子句中的常量值必须各不相同；
break 语句用来在执行完一个 case 分支后使程序跳出 switch 语句块；

注意：break标识是可选的，如果case分支中没有该标识，程序会按顺序执行直到遇到一个break标识的case分支，然后跳出 switch 语句块；

最后default 子句是可选的。当switch语句块没有匹配的 case 时分支时，则执行 default 语句。

switch语句的三个重要特征

switch语句只能进行相等性判断
同一switch语句中，两个case常量的值不允许相同，嵌套switch的除外
相对于一系列嵌套的if语句，switch语句的执行效率更高

3)、执行流程：

根据 switch表达式的值，依次匹配各个case。如果表达式的值等于某个case中定义的常量值，则执行对应case中的执行语句。
执行完此 case 的执行语句以后，检查语句块是否定义break关键字，若存在，则执行 break 并跳出当前的switch-case结构；若不存在break，则会继续执行当前 case 之后的其它 case 中的执行语句。直到遇到存在break 关键字或执行完所有的 case 及 default 的执行语句，再跳出当前的 switch结构

4)、应用举例：

case语句块存在break关键字

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;
}

执行结果：控制台输出 --> 夏日炎炎

case语句块不存在break关键字

String season = "spring";
switch (season) {
    case "spring":
        System.out.println("春暖花开");
    case "summer":
        System.out.println("夏日炎炎");
    case "autumn":
        System.out.println("秋高气爽");
    case "winter":
        System.out.println("冬雪皑皑");
        break;
    default:
        System.out.println("季节输入有误");
        break;
}

执行结果：控制台输出 -->

春暖花开

夏日炎炎

秋高气爽

冬雪皑皑

6、if-else语句与switch语句的比较

凡是使用 switch-case 的结构场景，都可以转换为 if-else 结构。可以使用if-else 结构的场景，则不一定可以使用switch-case 的结构
如果既可以使用 switch-case，又可以使用 if-else，建议使用 switch case。因为其效率稍高。
if-else 语句优点：

if 语句的条件是一个布尔类型值，if 条件表达式为 true 则进入分支，可以用于范围的判断，也可以用于等值的判断，其使用范围更广。

switch 语句的条件是一个常量值(byte,short,int,char,枚举,String)，只能判断某个变量或表达式的结果是否等于某个常量值，使用场景有限制。

switch 语句优点：

当条件是判断某个变量或表达式是否等于某个固定的常量值时，使用 if 和 switch 都可以，建议使用switch

当条件是区间范围的判断时，只能使用 if 语句。

使用 switch 可以利用穿透性，同时执行多个分支，而 if...else 没有穿透性。

三、迭代(循环)语句

迭代(循环)语句具有在某些条件满足的情况下，反复执行特定代码的功能
循环结构可分为while 循环、do-while 循环、for 循环
循环结构四要素包括：初始化部分、循环条件部分、循环体部分、迭代标识部分

1、while语句

1)、语法格式：

①初始化语句
while(②循环条件表达式判断)｛
        ③循环体执行语句块;
        ④迭代标识累加;
}

2)、说明：

while(循环条件)中循环条件必须是 boolean 类型。
注意不能省略【迭代标识累加;】，否则，循环将不会结束，从而形成死循环。
在每次循环开始时，就需要对条件表达式进行求值，如果第一次求值结果就为false，那么循环体里的语句一次也不会执行。

3)、执行流程： ①-②-③-④-②-③-④-②-③-④-...-②

4)、应用举例

//遍历 1-50 的偶数，并计算所有偶数的和、偶数的个数
int num = 1;
int sum = 0;//记录 1-100 所有的偶数的和
int count = 0;//记录 1-100之间偶数的个数
while(num <= 50){
    if(num % 2 == 0){
        System.out.println(num);
        sum += num;
        count++;
    }
    num++;//迭代条件
}
System.out.println("偶数的总和为：" + sum);
System.out.println("偶数的个数为：" + count);

2、do-while语句

1)、语法格式：

①初始化语句;
do{
    ③循环体执行语句块
    ④迭代标识累加
}while(②循环条件表达式判断);

2)、说明：

do-while 结构的循环体语句是至少会执行一次，
结尾 while(循环条件表达式)中循环条件表达式的计算结果必须是 boolean 类型
do{}while(); 最后有一个分号

3)、执行流程： ①-③-④-②-③-④-②-③-④-...-②

4)、应用举例

int num2 = 5;
do{
    System.out.println("hello:do-while");
    num2--;
}while(num2 > 5);

1)、语法格式：

for (①初始化语句; ②循环条件部分表达式; ④迭代标识累加)｛
     ③循环体语句块;
｝

2)、说明：

for循环的括号中的两个；不能多也不能少
第一次开始循环时，就执行①初始化语句，该部分通常设置为一个循环控制变量的表达式，该控制变量通常也作为控制循环的计数器，即④迭代标识累加变量
①初始化语句在整个循环执行过程中只会执行一次
①初始化部分可以声明多个变量，但必须是同一个类型，用逗号分隔
①初始化语句的作用域范围就是在for循环控制的语句范围内
②循环条件部分必须为 boolean 类型表达式，当值为 false 时，退出循环
④可以有多个变量更新，用逗号分隔

3)、执行流程：

①-②-③-④-②-③-④-②-③-④-.....-②

4)、应用举例

//循环遍历输出1-100以内的偶数 
for(int i = 1;i <= 100;i++){
    if(i % 2 == 0){
        System.out.println(i);
    } 
}

5)、关于for循环中的逗号操作符

此处的逗号操作符不是逗号分隔符，逗号分隔符用来分隔声明和函数的不同参数，在Java中唯一用到逗号操作符的地方就是foi循环的控制表达式；在控制表达式的初始化和迭代标识累加部分，都可以使用一系列由逗号分隔的语句，而这些语句会按先后顺序执行

通过使用逗号操作符，你可以在和1语句里定义多个变虽，但它们必须是相同的类型，如：

for(int i = 1, j = i + 10; i < 5; i++, j = i * 2){
    System.out.printIn("i=" + i + "j=" + j);
}

在以上for语句里的int参数定义包括i和j，在初始化部分可以定义同一个类型的任意数量的变量。在控制表达式里定义多个变量的能力只限于以上for循环，在其他任何选择或迭代语句中都不能使用这种方式。

4、for-in 语法

在JDK1.5中引入了一种更加简洁的for语法，可以用于数组和容器(集合)，这种语法就是通常所说的"増强的for循环"，或叫做"foreach"语法，

该语法仅能用于对数组和容器(集合)的迭代，对于for(int i = 1;i <= 100;i++){}这样存在迭代累加的场景，for-in语法不起作用，

语法格式：

for(Object 变量 : 数组或集合对象) {
}

应用举例

List<String> list = Arrays.asList("01_贷款","02_贴现","03_承兑","04_保函","05_信用证");
for (String str : list) {
    System.out.println(str);
}

String[] arrays = {"01_贷款","02_贴现","03_承兑","04_保函","05_信用证"};
for (String element : arrays) {
    System.out.println(element);
}

5、迭代(循环语句比较)

三种循环结构都具有四个要素：

循环变量的初始化条件
循环条件
循环体语句块
循环变量的修改的迭代表达式

从循环次数角度分析

do-while 循环至少执行一次循环体语句
for 和 while 循环先判断循环条件语句是否成立，然后决定是否执行循环体。

在实际应用场景该如何选择

遍历有明显的循环次数的场景，则选择使用 for 循环
遍历没有明显的循环次数的场景，则选择使用 while 循环
如果循环体语句块至少需要执行一次，则选择使用 do-while 循环

6、嵌套循环

所谓嵌套循环：是指在一个循环结构 A 的循环体语句块是另一个循环结构 B。如for 循环里面还有一个 for 循环，就是嵌套循环。

本质上，嵌套循环就是把内层循环当成外层循环的循环体。只有当内层循环的循环条件为 false 时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的外层循环。

假如设外层循环次数为 m 次，内层为 n 次，则内层循环体实际上需要执行 m*n 次。

在实际工作中，常见的嵌套循环是两层。一般不会出现超过三层的嵌套循环。如果超过三层的嵌套循环，会降低程序的可读性。如果在实际操作中，真正的出现了超过三层嵌套的情况，那么需要重新梳理业务逻辑，重新设计算法的实现，控制在三层以内

双层for循环应用举例

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

四、跳转语句

1、break：

1)、break的三种用途

用于终止switch语句中case的语句序列

如下代码片段：：从键盘输入星期的整数值，输出星期的英文单词。当输入的值满足某个case的值时，输出对应的星期几，然后使用break，终止其他case分支的执行。

Scanner input = new Scanner(System.in); 
int weekday = input.nextInt();
switch(weekday) {
    case 1:
        System.out.println("Monday");
        break;
    case 2:
        System.out.println("Tuesday");
        break;
    case 3:
        System.out.println("Wednesday");
        break;
    case 4:
        System.out.println("Thursday");
        break;
    case 5:
        System.out.println("Friday");
        break;
    case 6:
        System.out.println("Saturday");
        break;
    case 7:
        System.out.println("Sunday");
        break;
    default:
        System.out.println("你输入的星期值有误！");
        break;
}

用于循环语句中的退出循环执行。

如下代码片段：原意是while要循环100次，输出0-99的数，但在输出9的数字后，通过break强制终止循环体的执行，使后续的数字不在输出。

int i =0; 
while(i<100){
    if(i==10){
        break;
    }
    System.out.print( "  "+i);
    i++;
}

goto语句的改良用法，通过使用break语句，可以中断一个或多个代码块，这些代码不必是某个循环或switch语句的一部分，它可以是任何代码块。一般使用标签来进行工作，即 break label.

outer: for (int i=0;i<5;i++){
    System.out.println("Pass" + i +":");
    for (int k=0;k<100;k++){
        if(k==10){

            break outer;
        }
        System.out.print( k+"  ");

    }
    System.out.println("This will not print");
}
System.out.println("Loops complete");

执行结果：Pass0:

0 1 2 3 4 5 6 7 8 9 Loops complete

特别提示：break最初的设计目的并不是用来终止循环的正常手段，终止循环的循环中条件表达式要做的事。只有当发生某些特殊情况时，使用break语句强制终止循环的执行。

2、continue：

有时在程序执行时，需要提前终止循环的一次迭代，但是希望整个循环能继续运行，从循环控制的角度来说，就是希望程序跳过循环体，继续执行条件表达式。同时continue与break一样，也可以指定标签

1)、提前终止循环的一次迭代

for (int i=0;i<10;i++){
    System.out.println( i +" ");
    if(i%2==0){
        continue;
    }
    System.out.println(" ");
}

2)、指定标签

outer: for (int i=0;i<10;i++){
    for (int j=0;j<10;j++){
        if(j>i){
            System.out.println();
            continue outer;
        }
        System.out.print(" "+(i * j));

    }
}
System.out.println();