一、前言
记录时间 [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
语句:
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 中,可以使用标签 label
与 continue
语句结合,实现在嵌套循环中跳过指定的循环。
标签是放在循环语句之前的标识符,后面跟着一个冒号 :
使用标签与 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/