Java 笔记 10：Java 流程控制内容补充，常见的跳转语句，以及一些小案例

最新推荐文章于 2024-05-16 20:42:16 发布

蟾宫曲

最新推荐文章于 2024-05-16 20:42:16 发布

阅读量1.1k

点赞数 34

分类专栏： Java 基础篇文章标签： java 开发语言流程控制 intellij-idea 笔记

本文链接：https://blog.csdn.net/Sareur_1879/article/details/138346667

版权

Java 基础篇专栏收录该内容

16 篇文章 0 订阅

订阅专栏

一、前言

记录时间 [2024-04-30]

系列文章简摘：
Java 笔记 01：Java 概述，MarkDown 常用语法整理
 Java 笔记 02：Java 开发环境的搭建，IDEA / Notepad++ / JDK 安装及环境配置，编写第一个 Java 程序
 Java 笔记 03：Java 基础知识，使用 IDEA 创建 Java 项目、设置注释颜色，以及自动生成 JavaDoc
Java 笔记 09：Java 流程控制相关，常见的三种控制结构（顺序、选择、循环）

更多 Java 相关文章，请参考上面专栏哦。

本文是对 Java 流程控制相关内容的补充，包含常见的跳转语句如 break，continue 等等，以及一些流程控制的小案例。

二、跳转语句

1. 常见的跳转语句

在 Java 程序设计中，常见的控制结构主要有三种：顺序结构、选择结构和循环结构。

顺序结构：顺序结构是指程序按照代码书写的顺序依次执行，没有分支或循环。每一条语句都按照它们在代码中的顺序执行，直到到达程序的末尾。
选择结构：选择结构根据条件的真假选择不同的执行路径。常见的选择结构有 if-else 语句和 switch-case 语句。通过这些语句，程序可以根据不同的条件执行不同的代码块，从而实现分支控制。
循环结构：循环结构允许程序多次执行同一段代码，直到满足退出循环的条件。常见的循环结构有 for 循环、while 循环和 do-while 循环。这些循环结构允许程序根据条件重复执行某段代码，从而实现循环控制。

除了这三种主要的控制结构外，还有一些特殊的控制语句，如跳转语句（break、continue、return），它们能够在一定条件下改变程序的执行顺序或跳出当前的控制结构。

break 语句：break 语句用于在循环或 switch 语句中立即退出当前的循环或 switch 语句。当执行到 break 语句时，程序将跳出最内层的循环或 switch 语句，继续执行后续的代码。
continue 语句：continue 语句用于跳过当前循环中的剩余代码，并继续下一次循环的执行。在执行到 continue 语句时，程序会直接进入下一次循环的迭代。
return 语句：return 语句用于从当前的方法中返回值，并且结束方法的执行。在执行到 return 语句时，程序将立即返回调用该方法的地方，并且可以选择性地返回一个值。
throw 语句：throw 语句用于抛出异常。当程序执行到 throw 语句时，会创建一个异常对象，并将其抛出到调用堆栈中的上一层。通常用于手动抛出异常情况。
try-catch-finally 语句：try-catch-finally 语句用于处理异常。try 块包含了可能会抛出异常的代码，catch 块用于捕获并处理异常，finally 块用于执行无论是否发生异常都需要执行的代码。

2. break 语句

break 语句是一种控制语句，用于在循环或者 switch 语句中提前退出。在循环中，break 语句会立即终止当前的循环，然后执行循环后的代码。在 switch 语句中，break 语句用于退出 switch 语句块，防止执行其他情况的分支。

在循环中使用 break 语句：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break; // 当 i 等于 5 时跳出循环
    }
    System.out.println(i);
}

在这个案例中，当 i 的值为 5 时，会跳出这个循环。

在 switch 语句中使用 break 语句：

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

在这个案例中，当 num 的值为 2 时，将会输出 “数字为 2”，然后 break 语句使得程序退出 switch 语句块，而不会继续执行 default 分支。

3. continue 语句

continue 语句是一种控制语句，用于结束当前循环的当前迭代，并立即开始下一次迭代。当程序执行到 continue 语句时，它会跳过当前循环中 continue 语句之后的所有代码，直接进入下一次循环的迭代。

跳过当前迭代

continue 语句通常与条件语句结合使用，用于在满足特定条件时跳过当前迭代。

在循环中使用 continue 语句：

for (int i = 0; i < 5; i++) {
    if (i == 2) {
        continue; // 当 i 等于 2 时跳过当前迭代，进入下一次迭代
    }
    System.out.println(i);
}

在这个案例中，当 i 的值等于 2 时，continue 语句将跳过 System.out.println(i); 的执行，直接进入下一次循环的迭代。因此，输出结果将不包含 2。

跳转标签

在 Java 中，可以使用标签 label 与 continue 语句结合，实现在嵌套循环中跳过指定的循环。

标签是放在循环语句之前的标识符，后面跟着一个冒号 :

使用标签与 continue 语句结合可以方便地控制程序在嵌套循环中的流程，但应该谨慎使用，避免过度复杂的控制流程使代码难以理解。

以下是一个示例，演示了如何在嵌套循环中使用标签与 continue 语句：

outerLoop: // 外层循环的标签

for (int i = 0; i < 3; i++) {
    
    innerLoop: // 内层循环的标签
    
    for (int j = 0; j < 3; j++) {
        if (i == 1 && j == 1) {
            continue outerLoop; // 跳过外层循环的当前迭代
        }
        System.out.println("i = " + i + ", j = " + j);
    }
    
}

在上面的示例中，当内层循环的条件 i == 1 && j == 1 满足时，continue outerLoop; 语句将跳过外层循环的当前迭代。

这是因为 continue outerLoop; 语句中的 outerLoop 是外层循环的标签。

因此，当 continue 语句执行时，程序会跳过外层循环的当前迭代，直接进入外层循环的下一次迭代。

三、相关案例

1. 计算奇数偶数和

使用 Java 编写一个程序来计算 0 到 100 之间的奇数和和偶数和。下面是两个简单的 Java 程序示例：

使用 for 循环

public class Main {
    public static void main(String[] args) {
        int sumEven = 0;
        int sumOdd = 0;

        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                sumEven += i; // 如果是偶数，加到偶数和上
            } else {
                sumOdd += i; // 如果是奇数，加到奇数和上
            }
        }

        System.out.println("0 到 100 之间的偶数和为：" + sumEven);
        System.out.println("0 到 100 之间的奇数和为：" + sumOdd);
    }
}

使用 while 循环

public class Main {
    public static void main(String[] args) {
        int sumEven = 0;
        int sumOdd = 0;
        int i = 0;

        while (i <= 100) {
            if (i % 2 == 0) {
                sumEven += i; // 如果是偶数，加到偶数和上
            } else {
                sumOdd += i; // 如果是奇数，加到奇数和上
            }
            
            i++;
        }

        System.out.println("0 到 100 之间的偶数和为：" + sumEven);
        System.out.println("0 到 100 之间的奇数和为：" + sumOdd);
    }
}

2. 输出整除数

使用 for 循环或者 while 循环来实现输出 1-1000 之间能被 5 整除的数，并且每行输出 3 个。

使用 for 循环

public class Main {
    public static void main(String[] args) {
        int count = 0; // 计数器，用于控制每行输出的数量

        for (int i = 1; i <= 1000; i++) {
            if (i % 5 == 0) { // 判断能否被5整除
                System.out.print(i + " "); // 输出能被5整除的数
                count++; // 计数器加1

                // 当计数器达到3时换行，并重置计数器
                if (count == 3) {
                    System.out.println();
                    count = 0;
                }
            }
        }
    }
}

不用计数器情况

public class Main {
    public static void main(String[] args) {

        for (int i = 1; i <= 1000; i++) {
            if (i % 5 == 0) { // 判断能否被5整除
                System.out.print(i + " "); // 输出能被5整除的数
            }
            if (i % 15 == 0) { // 判断能否被15整除
                System.out.println();	// 3*5=15，做到三个数换行
            }
        }
    }
}

3. 打印九九乘法表

使用嵌套的 for 循环来打印九九乘法表。下面是一个简单的 Java 程序示例：

简便处理

public class Main {
    public static void main(String[] args) {
        // 使用嵌套的 for 循环打印九九乘法表
        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();
        }
    }
}

末尾没有空格

如果不希望末尾有空格，最后一个式子单独处理。

经过观察可以发现，九九乘法表每行的最后一个式子，两个乘积因子相同。

由此判断，当两个乘积因子相同时，是每行的最后一个式子，输出时不带空格。

public class NineNineTable {

    public static void main(String[] args) {

        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                
                // 如果不希望末尾有空格，最后一个式子单独处理
                if (i == j) {
                    System.out.println(j + "*" + i + "=" + j*i);
                } else {
                    System.out.print(j + "*" + i + "=" + j*i + "\t");
                }

            }

        }

    }

}

4. 判断素数

素数 / 质数是指大于 1 的自然数，除了 1 和它本身之外，不能被任何其他自然数整除的数。即，素数只有两个正因数：1 和它本身。比如，2、3、5、7、11 等都是素数，因为它们只能被 1 和自身整除，而无法被其他自然数整除。

接下来用 3 种方式打印 101-150 之间的质数，并计算总数。

break 方式

使用 break 方式，由于质数除了 1 和它本身之外，不能被任何其他自然数整除，所以如果出现了整除，不是质数，break 跳出循环。

这个程序使用了一个循环从 2 到该数的一半，检查是否能被这些数整除，如果能则不是质数。如果都不能被整除，则是质数。

public static void breakteat() {
    int j;
    int count = 0;
    
    for (int i=101; i<=150; i++) {
        
        // 从 2 到该数的一半，也可以到平方根
        for (j=2; j<i/2; j++) {
            
            // 如果出现了整除，不是质数，break 跳出循环
            if (i%j == 0) {
                break;
            }
        }
        
        if (j == i/2) {
            System.out.println(i);
            count++;
        }
    
    }
    
    System.out.println("count = " + count);

}

continue + label

使用 continue + label 的方式来实现，如果出现了整除，不是质数 continue 跳转到 outer 标签。

outer 标签定义在外循环。

public static void labeltest() {
    int count = 0;
    
    outer: for (int i=101; i<=150; i++) {
        
        for (int j=2; j<i/2; j++) {
            
            // 如果出现了整除，不是质数 continue 跳转到 outer 标签
            if (i%j == 0) {
                continue outer;
            }
        }
        
        System.out.println(i);
        count++;
    
    }
    
    System.out.println("count = " + count);

}

单独写方法

也可以单独写一个检查一个数是否是质数的方法。

这个程序会遍历 101 到 150 之间的每一个数，然后调用 isPrime 方法检查是否是质数。isPrime 方法中，使用了一个循环从 2 到该数的平方根，检查是否能被这些数整除，如果能则不是质数。如果都不能被整除，则是质数。

public class Main {
    
    public static void main(String[] args) {
        // 打印 101 到 150 之间的质数
        for (int num = 101; num <= 150; num++) {
            if (isPrime(num)) {
                System.out.println(num);
            }
        }
    }

    // 检查一个数是否是质数的方法
    public static boolean isPrime(int num) {
        if (num <= 1) {
            return false;
        }
        for (int i = 2; i <= Math.sqrt(num); i++) {
            if (num % i == 0) {
                return false; // 如果能被i整除，则不是质数
            }
        }
        return true; // 如果不能被 2 到 sqrt(num) 中的任何数整除，则是质数
    }
}

5. 打印三角形

要打印一个三角形，可以使用嵌套循环来控制行数和每行的星号数量。

直角三角形

这个程序会打印一个直角三角形，行数由 rows 变量指定。外层循环控制行数，内层循环控制每行的星号数量。每打印完一行星号，就会换行。可以根据需要修改 rows 变量的值来调整三角形的大小。

public class Main {
    public static void main(String[] args) {
        int rows = 5; // 三角形的行数

        // 外层循环控制行数
        for (int i = 1; i <= rows; i++) {
            // 内层循环控制每行的星号数量
            for (int j = 1; j <= i; j++) {
                System.out.print("* ");
            }
            // 每打印完一行星号换行
            System.out.println();
        }
    }
}

等腰三角形

要打印一个等腰三角形，可以使用嵌套循环来控制行数和每行的星号数量。

等腰三角形的每行星号数量呈现出一定的规律，可以通过控制空格和星号的数量来实现。

以下是一个示例程序，打印一个等腰三角形：

public class Main {
    public static void main(String[] args) {
        int rows = 5; // 三角形的行数

        // 外层循环控制行数
        for (int i = 1; i <= rows; i++) {
            // 内层循环控制每行的空格数量
            for (int j = 1; j <= rows - i; j++) {
                System.out.print(" "); // 打印空格
            }
            // 内层循环控制每行的星号数量
            for (int k = 1; k <= 2 * i - 1; k++) {
                System.out.print("*"); // 打印星号
            }
            // 每打印完一行星号换行
            System.out.println();
        }
    }
}

四、总结

本文是对 Java 流程控制相关内容的补充，包含常见的跳转语句如 break，continue 等等，以及一些流程控制的小案例。

一些参考资料

狂神说 Java 零基础：https://www.bilibili.com/video/BV12J41137hu/
TIOBE 编程语言走势： https://www.tiobe.com/tiobe-index/
Typora 官网：https://www.typoraio.cn/
Oracle 官网：https://www.oracle.com/
Notepad++ 下载地址：https://notepad-plus.en.softonic.com/
IDEA 官网：https://www.jetbrains.com.cn/idea/
Java 开发手册：https://developer.aliyun.com/ebook/394
Java 8 帮助文档：https://docs.oracle.com/javase/8/docs/api/