2.4流程控制语句

最新推荐文章于 2025-05-01 20:06:47 发布

chxii

最新推荐文章于 2025-05-01 20:06:47 发布

阅读量740

点赞数 22

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/chxii/article/details/147618999

版权

java 专栏收录该内容

18 篇文章

订阅专栏

流程控制语句能对程序的执行流程进行控制。下面详细介绍 Java 中的各类流程控制语句。

1. 顺序结构

顺序结构是程序最基本的结构，代码会依照书写顺序依次执行。

public class SequenceStructure {
    public static void main(String[] args) {
        System.out.println("第一步");
        System.out.println("第二步");
        System.out.println("第三步");
    }
}

在上述代码中，语句会按照书写顺序，依次输出 “第一步”“第二步”“第三步”。

2. 选择结构

选择结构依据条件判断的结果来决定执行哪部分代码。Java 中的选择结构有 if-else 语句和 switch 语句。

`if-else` 语句

if-else 语句可分为单分支、双分支和多分支。

单分支：

public class IfSingleBranch {
    public static void main(String[] args) {
        int num = 10;
        if (num > 5) {
            System.out.println("数字大于 5");
        }
    }
}

若 num 大于 5，就会执行 if 语句块中的内容。

双分支：

public class IfElseDoubleBranch {
    public static void main(String[] args) {
        int num = 3;
        if (num > 5) {
            System.out.println("数字大于 5");
        } else {
            System.out.println("数字小于等于 5");
        }
    }
}

若 num 大于 5，执行 if 语句块；否则执行 else 语句块。

多分支：

public class IfElseMultiBranch {
    public static void main(String[] args) {
        int score = 85;
        if (score >= 90) {
            System.out.println("优秀");
        } else if (score >= 80) {
            System.out.println("良好");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
    }
}

程序会依次判断条件，当某个条件为 true 时，执行对应的语句块，之后不再进行后续条件判断。

`switch` 语句

switch 语句依据表达式的值来选择执行的分支。

public class SwitchStatement {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            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;
            default:
                System.out.println("输入无效");
        }
    }
}

当 day 的值与某个 case 后面的值相等时，就会执行该 case 语句块，若没有匹配的 case，则执行 default 语句块。break 语句用于终止 switch 语句的执行。

在 Java 7 之前，switch 表达式仅支持 byte、short、char、int 及其对应的包装类，还有枚举类型。从 Java 7 开始，switch 表达式也支持 String 类型

常量表达式：case 后面的值必须是常量表达式，不能是变量或者带有变量的表达式。
唯一性：case 标签的值必须唯一，不允许有重复的值。
终止执行：break 语句的作用是终止 switch 语句的执行。若没有 break 语句，程序会继续执行下一个 case 语句块，直至遇到 break 或者 switch 语句结束，这就是所谓的 “穿透” 现象。

可任意放置：default 标签用于处理 case 标签都不匹配的情况，它的位置可以任意放置，不一定要放在最后。不过，为了代码的可读性，通常将其放在最后。

int num = 3;
switch (num) {
    default:
        System.out.println("其他数字");
        break;
    case 1:
        System.out.println("数字是 1");
        break;
    case 2:
        System.out.println("数字是 2");
        break;
}

新特性：从 Java 12 开始，switch 语句得到了增强，成为了 switch 表达式，可以有返回值。使用 -> 语法，并且可以省略 break 语句。

int num = 2;
String result = switch (num) {
    case 1 -> "数字是 1";
    case 2 -> "数字是 2";
    default -> "其他数字";
};
System.out.println(result);

3. 循环结构

循环结构能够让一段代码重复执行。Java 中的循环结构有 for 循环、while 循环和 do-while 循环。

`for` 循环

for 循环适合在已知循环次数的情况下使用。

public class ForLoop {
    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            System.out.println("当前数字是: " + i);
        }
    }
}

在这个例子里，循环变量 i 从 0 开始，每次循环 i 自增 1，当 i 小于 5 时，继续循环。

`while` 循环

while 循环先判断条件，若条件为 true 则执行循环体。

public class WhileLoop {
    public static void main(String[] args) {
        int i = 0;
        while (i < 5) {
            System.out.println("当前数字是: " + i);
            i++;
        }
    }
}

在这个例子中，只有当 i 小于 5 时，才会执行循环体。

`do-while` 循环

do-while 循环先执行一次循环体，再判断条件，若条件为 true 则继续循环。

public class DoWhileLoop {
    public static void main(String[] args) {
        int i = 0;
        do {
            System.out.println("当前数字是: " + i);
            i++;
        } while (i < 5);
    }
}

无论初始条件是否成立，do-while 循环的循环体至少会执行一次。

4. 跳转语句

跳转语句用于改变程序的执行流程，Java 中的跳转语句有 break、continue 和 return。

`break` 语句

break 语句用于终止当前所在的循环或 switch 语句。

public class BreakStatement {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                break;
            }
            System.out.println("当前数字是: " + i);
        }
    }
}

当 i 等于 5 时，执行 break 语句，终止整个 for 循环。

`continue` 语句

continue 语句用于跳过当前循环体中剩余的语句，直接进入下一次循环。

public class ContinueStatement {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                continue;
            }
            System.out.println("当前数字是: " + i);
        }
    }
}

当 i 等于 5 时，执行 continue 语句，跳过本次循环中 System.out.println 语句，直接进入下一次循环。

`return` 语句

return 语句用于从方法中返回值，并终止方法的执行。

public class ReturnStatement {
    public static int sum(int a, int b) {
        return a + b;
    }

    public static void main(String[] args) {
        int result = sum(3, 5);
        System.out.println("两数之和是: " + result);
    }
}

在 sum 方法中，return a + b 语句返回两数之和，并终止 sum 方法的执行。

死循环

死循环指的是程序中一类循环结构，这类循环会持续执行，没有自然终止的条件，除非有外部干预（如程序被强制终止），循环会一直运行下去。在实际编程里，死循环有时会被用于特定需求，不过更多时候是由于编程失误产生的。

常见的死循环形式

`while` 循环实现的死循环

public class InfiniteWhileLoop {
    public static void main(String[] args) {
        while (true) {
            // 这里的代码会一直执行
            System.out.println("这是一个 while 死循环");
        }
    }
}

在这个例子中，while 循环的条件是 true，这意味着条件始终为真，循环体会一直执行。

`for` 循环实现的死循环

public class InfiniteForLoop {
    public static void main(String[] args) {
        for (;;) {
            // 这里的代码会一直执行
            System.out.println("这是一个 for 死循环");
        }
    }
}

在这个 for 循环里，没有初始化语句、条件判断语句和迭代语句，这就使得循环没有终止条件，会一直执行下去。

`do-while` 循环实现的死循环

public class InfiniteDoWhileLoop {
    public static void main(String[] args) {
        do {
            // 这里的代码会一直执行
            System.out.println("这是一个 do-while 死循环");
        } while (true);
    }
}

do-while 循环会先执行一次循环体，之后判断条件。由于条件是 true，循环体会持续执行。

死循环的用途

虽然死循环通常被视为编程错误，但在某些场景下也有实际用途，

import java.util.Scanner;

public class InputListening {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("开始监听用户输入，输入 'quit' 退出。");

        while (true) {
            System.out.print("请输入内容: ");
            String input = scanner.nextLine();

            if ("quit".equalsIgnoreCase(input)) {
                System.out.println("退出监听。");
                break;
            }

            System.out.println("你输入的内容是: " + input);
        }

        scanner.close();
    }
}

嵌套循环详解

嵌套循环指的是在一个循环体内部再嵌套另一个或多个循环。外层循环每执行一次，内层循环会完整地执行一轮。嵌套循环常用于处理二维数据结构，如二维数组，或者需要多次嵌套迭代的场景。

嵌套 `for` 循环打印九九乘法表

public class MultiplicationTable {
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + " * " + i + " = " + (i * j) + "\t");
            }
            System.out.println();
        }
    }
}

在这个例子中，外层 for 循环控制行数，内层 for 循环控制每行的列数。外层循环每执行一次，内层循环会根据当前 i 的值执行相应的次数，从而打印出一行乘法表。