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

一、前言

记录时间 [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 循环。这些循环结构允许程序根据条件重复执行某段代码,从而实现循环控制。

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

  • 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 语句:

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

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


switch 语句中使用 break 语句:

java 复制代码
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 语句:

java 复制代码
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 中,可以使用标签 labelcontinue 语句结合,实现在嵌套循环中跳过指定的循环

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

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

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

java 复制代码
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 循环

java 复制代码
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 循环

java 复制代码
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 循环

java 复制代码
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;
                }
            }
        }
    }
}

不用计数器情况

java 复制代码
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 程序示例:

简便处理

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

末尾没有空格

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

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

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

java 复制代码
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 到该数的一半,检查是否能被这些数整除,如果能则不是质数。如果都不能被整除,则是质数。

java 复制代码
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 标签定义在外循环。

java 复制代码
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 到该数的平方根,检查是否能被这些数整除,如果能则不是质数。如果都不能被整除,则是质数。

java 复制代码
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 变量的值来调整三角形的大小。

java 复制代码
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();
        }
    }
}

等腰三角形

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

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

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

java 复制代码
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/

相关推荐
morris131几秒前
【SpringBoot】Xss的常见攻击方式与防御手段
java·spring boot·xss·csp
Source.Liu17 分钟前
【用Rust写CAD】第二章 第四节 函数
开发语言·rust
monkey_meng18 分钟前
【Rust中的迭代器】
开发语言·后端·rust
余衫马20 分钟前
Rust-Trait 特征编程
开发语言·后端·rust
monkey_meng24 分钟前
【Rust中多线程同步机制】
开发语言·redis·后端·rust
七星静香25 分钟前
laravel chunkById 分块查询 使用时的问题
java·前端·laravel
Jacob程序员26 分钟前
java导出word文件(手绘)
java·开发语言·word
ZHOUPUYU26 分钟前
IntelliJ IDEA超详细下载安装教程(附安装包)
java·ide·intellij-idea
stewie630 分钟前
在IDEA中使用Git
java·git
小白学大数据33 分钟前
正则表达式在Kotlin中的应用:提取图片链接
开发语言·python·selenium·正则表达式·kotlin