Java基本语法_04_控制语句

Java
发布日期:   2021-09-24
更新日期:   2021-09-28
文章字数:   2.1k
阅读时长:   8 分
阅读次数:  

有了数据，有了运算，那么如何控制数据运算的过程呢？这就需要有控制语句，也称为控制结构。程序主要有三种结构：顺序结构，选择结构和循环结构。正常情况下，程序都是自上而下执行的，这就是顺序结构，前面的例子都是顺序结构。下面介绍选择结构和循环结构。

1. 选择结构

选择结构也被称为分支结构。选择结构最简单的例子就是男女厕所，男性去男厕所，女性去女厕所。除此之外，有时候会遇到多分支，比如年龄段，0~7岁，7~18岁，18~25岁等等。就是说满足某个条件就去执行特定的语句，其他语句不执行，Java语言提供了两种分支结构：if分支和switch分支。

1.1 if分支结构

if分支语句也被称为条件控制语句，满足条件(布尔表达式为true)则执行该分支的语句，其他分支语句不执行。语法结构有四种。注意，如果if语句的分支中只有一条java语句，大括号可以省略不写，为了保证规整性，建议写上大括号。

  1. 第一种

    1
    2
    3
    4
    5
    6
    if(布尔表达式){
        // 如果布尔表达式为true，则进入大括号执行语句，否则不进入
        Java语句;
        Java语句;
        ...
    }

  2. 第二种

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    if(布尔表达式){
        // 布尔表达式为true，执行语句，并跳过else。
        Java语句;
        Java语句;
        ...
    }else{
        // 布尔表达式为false，跳过上面，进入else括号，执行语句。
        Java语句;
        Java语句;
        ...
    }

  3. 第三种

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    if(布尔表达式1){
        // 布尔表达式1为true，执行语句，并跳过后面的其他if分支
        Java语句;
        Java语句;
        ...
    }else if(布尔表达式2){
        // 布尔表达式1为false，且2为true，执行语句，并跳过后面其他if分支
        Java语句;
        Java语句;
        ...
    }else if(布尔表达式3){
        // 布尔表达式1和2为false，且3为true，执行语句。
        Java语句;
        Java语句;
    }...

  4. 第四种

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    if(布尔表达式1){
        Java语句;
        Java语句;
        ...
    }else if(布尔表达式2){
        Java语句;
        Java语句;
        ...
    }...
    else{
        // 和上面的一样，只不过多一个else分支，当所有的表达式都为false时执行本段代码。
        Java语句;
        Java语句;
        ...
    }

1.2 switch分支结构

switch语句的语法结构如下：(switch括号里面的数据和各个case的值进行匹配，如果哪个匹配了，就执行该分支，遇到break就退出switch，如果没遇到break，则继续执行后面的case（不再进行匹配，称为case穿透），直到遇到break退出；所有分支都没有匹配成功的话，如果有default的话，则执行该分支。)

注意：switch条件中只能是 int 或 String类型的，当然byte，short，char也可以直接写到switch和case后面，因为它们可以自动类型转换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
switch(int 或 String 类型的字面值或变量){
    case int 或 String 类型的字面值或变量:
        java语句;
        java语句;
        ...
        break;
    case int 或 String 类型的字面值或变量:
        java语句;
        java语句;
        ...
        break;
    ...
    default:
        java语句;
        ...
}

简单例子如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// case也可以合并，相当于某个case没有Java语句，没有break。
// 下面的就是1,2,3,10进行了合并。
int i = 10;
switch(i){
    case 1: case 2: case 3: case 10:
        System.out.println(100);
        break;
    case 5:
        System.out.println(1000);
        break;
    default:
        System.out.println(2500);
        break;
}

2. 循环结构

在程序当中总有一些需要反复的、重复的执行的代码，假设没有循环结构，那么这段需要重复执行的代码自然是需要重复编写的。代码无法得到重复使用。所以多数编程语言都是支持循环结构的。将来把需要反复执行的代码片段放到“循环体”，再联合“计数器”，共同控制这段需要反复执行的代码。

基本上所有的编程语言支持的循环包括三种：

  • for循环；
  • while循环；
  • do…while循环；

2.1 for循环

语法结构如下：

1
2
3
4
5
for(初始化表达式; 布尔表达式; 更新表达式){
    Java语句;
    Java语句;
    ...
}

初次进入循环的时候，先执行初始化表达式，然后判断布尔表达式，为true，则进入循环，执行循环体，然后执行更新表达式；接着继续判断布尔表达式，如此循环，直到布尔表达式为false，退出循环。

另外，初始化表达式和更新表达式均可省略，其中初始化表达式需要在循环前面表示，更新表达式可在循环体中表示。

2.2 while循环

语法结构如下：

1
2
3
4
5
while(布尔表达式){
    Java语句;
    Java语句;
    ...
}

执行过程和for循环类似，相当于省略了初始化表达式和更新表达式。每次都判断布尔表达式是否为true，为false则退出循环。

2.3 do…while循环

语法结构如下：

1
2
3
4
5
do{
    Java语句;
    Java语句;
    ...
}while(布尔表达式);

先执行Java语句，再判断布尔表达式是否为true。这种循环至少执行一次循环体。

2.4 控制语句

循环语句是循环执行的，有时候需要特殊控制一下循环流程，比如满足某些条件时不执行某些语句，满足某些条件时退出循环。Java提供了以下两种控制语句。

  1. break;

    break是Java语言当中的关键字，被翻译为“中断”；

    break 和 “**;**”可以成为一个单独的完整的java语句：break;

    break语句使用在switch语句当中，用来终止switch的语句执行。

    break语句同样可以使用在循环语句当中，用来终止循环的执行，即跳出循环，提高程序的执行效率。

  2. continue;

    continue是Java语言当中的关键字，被翻译为“继续下一个”。

    使用在循环语句中，用来终止本次循环，即该语句后的其他循环语句不再执行，提前进入下一次循环。

3. 例子

3.1 if分支结构案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Example {

    public static void main(String[] args){

        int age = 17;

        if(age < 18){
            // 年龄小于18周岁
            System.out.println("该学生的年龄未满18周岁，不能进入网吧！");
        }else if(age < 35){
            // 年龄在 18~35之间
            System.out.println("该学生的年龄已满18周岁，可进入网吧，建议上网时长为2小时！");
        }else{
            // 年龄大于35周岁
            System.out.println("该学生的年龄处于中年人，可进入网吧，建议上网时长为1小时！");
        }
    }

}

3.2 switch分支结构案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public class Example {

    public static void main(String[] args){

        int score = 79;

        // 这里注意除法的应用，因为score和10都是int类型，所以二者计算的结果也会被自动转换为int，所以相当于向下取整。如果想要得到准确的浮点结果，需要将二者任意一个转换为浮点类型。
        switch(score / 10){
            case 0:
            case 1:
            case 2:
            case 3:
            case 4:
            case 5:
                System.out.println("该学生的成绩等级为E");
                break;
            case 6:
                System.out.println("该学生的成绩等级为D");
                break;
            case 7:
                System.out.println("该学生的成绩等级为C");
                break;
            case 8:
                System.out.println("该学生的成绩等级为B");
                break;
            case 9:
            case 10:
                System.out.println("该学生的成绩等级为A");
        }
    }
}

3.3 for循环结构案例

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Example {

    public static void main(String[] args){

        int sum = 0;

        for(int i=1; i <= 100; i++){
            sum += i;
        }

        System.out.println("100以内的求和为：" + sum);
    }
}

3.4 while循环结构案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Example {

    public static void main(String[] args){

        int sum = 0;
        int i = 1;

        while(i <= 100){
            sum += i;
            i += 2;
        }

        System.out.println("100以内的奇数求和为：" + sum);
    }
}

3.5 do…while循环结构案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Example {

    public static void main(String[] args){

        int sum = 0;
        int i = 2;

        do{
            sum += i;
            i += 2;
        }while(i <= 100);

        System.out.println("100以内的偶数求和为：" + sum);
    }
}

3.6 控制语句案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Example {

    public static void main(String[] args){

        int sum = 0;
        int i = 1;

        for(;i <= 100; i++){

            if(i == 50){
                break;
            }else if(i % 2 == 1){
                continue;
            }

            sum += i;
        }

        System.out.println("50以内的偶数求和为：" + sum);

    }
}

4. 备注

参考B站《动力节点》。

文章作者: 浮云
文章链接: https://ihianian.github.io/2021/09/24/Java%E5%9F%BA%E6%9C%AC%E8%AF%AD%E6%B3%95-04-%E6%8E%A7%E5%88%B6%E8%AF%AD%E5%8F%A5/
版权声明: 本博客所有文章除特別声明外，均采用 CC BY 4.0 许可协议。转载请注明来源 浮云 !
Java
赏
  目录