一、if 语句
在 Java 中，if 语句是一种条件控制语句，用于根据条件的真假来决定是否执行特定的代码块。以下是关于 if 语句的详细介绍：
1.1 单分支
语法结构： 计算条件表达式的值，如果该值为 true，则执行 if 语句块中的代码；如果为 false，则跳过该代码块，继续执行后续代码。
if (条件表达式) {
// 当条件表达式为 true 时执行
}
示例代码：
public class Main{
public static void main(String[] args) {
int age = 18;
if (age >= 18) {
System.out.println("已成年");
}
}
}
运行结果：
已成年
1.2 双分支
语法结构： 计算条件表达式的值，若为 true，执行 if 语句块中的代码；若为 false，则执行 else 语句块中的代码。
if (条件表达式) {
// 当条件表达式为 true 时执行
} else {
// 当条件表达式为 false 时执行
}
示例代码：
public class Main{
public static void main(String[] args) {
int age = 17;
if (age >= 18) {
System.out.println("已成年");
}else {
System.out.println("未成年");
}
}
}
运行结果：
未成年
1.3 多分支
语法结构： 依次计算各个条件表达式的值，一旦某个条件表达式的值为 true，就执行对应的代码块，然后跳过后续的 else if 和 else 部分；如果所有条件表达式的值都为 false，则执行 else 语句块中的代码（如果有 else 部分）。
if (条件表达式 1) {
// 当条件表达式 1 为 true 时执行
} else if (条件表达式 2) {
// 当条件表达式 1 为 false 且条件表达式 2 为 true 时执行
} else if (条件表达式 3) {
// 当条件表达式 2 为 false 且条件表达式 3 为 true 时执行
}
// 可以有多个 else if 语句
else {
// 当所有条件表达式都为 false 时执行的代码块
}
示例代码：
public class Main {
public static void main(String[] args) {
int score = 75;
if (score >= 90) {
System.out.println("成绩为 A");
} else if (score >= 80) {
System.out.println("成绩为 B");
} else if (score >= 70) {
System.out.println("成绩为 C");
} else if (score >= 60) {
System.out.println("成绩为 D");
} else {
System.out.println("成绩为 F");
}
}
}
运行结果：
成绩为 C
1.4 嵌套分支
语法结构： if 语句块内部还可以再嵌套 if 语句，形成嵌套的条件判断。
if (条件表达式 1) {
if (条件表达式 2) {
// 当条件表达式 1 和条件表达式 2 都为 true 时执行的代码块
}
}
示例代码：
public class Main {
public static void main(String[] args) {
int age = 25;
boolean hasLicense = true;
if (age >= 18) {
if (hasLicense) {
System.out.println("可以开车");
} else {
System.out.println("年龄够了但没有驾照，不能开车");
}
} else {
System.out.println("年龄不够，不能开车");
}
}
}
运行结果：
可以开车
1.5 注意事项
-
条件表达式：条件表达式的结果必须是布尔类型（true 或 false）。
-
代码块：如果 if、else if 或 else 后面只有一条语句，可以省略大括号。但为了代码的可读性和避免潜在的错误，建议始终使用大括号，知道有这个语法就可以了。
二、switch 语句
在 Java 中，switch 语句是一种多分支选择语句，用于根据表达式的值来执行不同的代码块。以下是关于 switch 语句的详细介绍：
2.1 基本语法（Java 7 及以前）
语法结构：
switch (表达式) {
case 值 1:
// 当表达式的值等于值 1 时执行
break;
case 值 2:
// 当表达式的值等于值 2 时执行
break;
// 可以有多个 case 语句
default:
// 当表达式的值与所有 case 的值都不匹配时执行
}
- 表达式： 可以是 byte、short、char、int 类型，在 Java 5 及以后，还支持 enum（枚举）类型，Java 7 及以后支持 String 类型。
- case： 每个 case 后面跟一个常量值，用于与表达式的值进行比较。当表达式的值等于某个 case 后面的值时，就会执行该 case 下的代码块。
- break： 用于终止 switch 语句的执行。如果没有 break，程序会继续执行下一个 case 中的代码，直到遇到 break 或 switch 语句结束，这称为
case 穿透现象。 - default： 可选的，当表达式的值与所有 case 的值都不匹配时，会执行 default 下的代码块。
代码示例：
public class Main {
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("输入的数字不是有效的星期数");
}
}
}
运行结果：
星期三
2.2 增强 switch 语句（Java 12 及以后）
从 Java 12 开始，switch 语句得到了增强，引入了新的语法形式，使得代码更加简洁和灵活。
箭头语法：
switch (表达式) {
case 值 1 -> {
// 当表达式的值等于值 1 时执行的代码
}
case 值 2 -> System.out.println("执行简单语句");
// 可以有多个 case 语句
default -> {
// 当表达式的值与所有 case 的值都不匹配时执行的代码
}
}
注意：使用 -> 箭头语法时，如果代码块只有一条语句，可以省略大括号。这种语法避免了 case 穿透 问题，因为它不会自动执行下一个 case。
表达式使用：
在 Java 13 及以后，switch 可以作为表达式使用，即可以返回一个值。
public class Main {
public static void main(String[] args) {
int num = 2;
String result = switch (num) {
case 1 -> "数字 1";
case 2 -> "数字 2";
default -> "其他数字";
};
System.out.println(result);
}
}
运行结果：
数字 2
yield 关键字：
如果 switch 表达式的代码块需要执行多条语句，并且要返回一个值，可以使用 yield 关键字。
public class Main {
public static void main(String[] args) {
int num = 3;
String result = switch (num) {
case 1 -> {
System.out.println("这是数字 1");
yield "数字 1";
}
case 2 -> {
System.out.println("这是数字 2");
yield "数字 2";
}
default -> {
System.out.println("这是其他数字");
yield "其他数字";
}
};
System.out.println(result);
}
}
运行结果：
这是其他数字
其他数字
2.3 注意事项
-
在使用传统 switch 语句时，要注意合理使用 break 避免
case 穿透现象。 -
增强 switch 语句提供了更简洁和安全的语法，但需要使用 Java 12 及以上版本。
三、for 循环
在 Java 中，for 循环是一种常用的循环结构，用于重复执行特定的代码块。Java 提供了三种不同形式的 for 循环：基本 for 循环、增强 for 循环和 for 语句的变体。下面为你详细介绍这三种 for 循环。
3.1 基本 for 循环
语法结构：
for (初始化表达式; 布尔表达式; 迭代表达式) {
// 循环体，需要重复执行的代码
}
代码解释：
- 初始化表达式：在循环开始前执行，通常用于声明和初始化循环控制变量，只执行一次。
- 布尔表达式：在每次循环迭代前进行计算，如果结果为 true，则执行循环体；如果为 false，则退出循环。
- 迭代表达式：在每次循环体执行完毕后执行，通常用于更新循环控制变量的值。
执行流程：
- 执行初始化表达式，声明并初始化变量 i 为 1。
- 计算布尔表达式 i <= 5，结果为 true，执行循环体，打印 i 的值。
执行迭代表达式 i++，i 的值变为 2。 - 再次计算布尔表达式，若结果为 true，继续执行循环体和迭代表达式；若为 false，则退出循环。
代码示例：
public class Main {
public static void main(String[] args) {
// 打印 1 到 5 的数字
for (int i = 1; i <= 5; i++) {
System.out.println(i);
}
}
}
运行结果：
1
2
3
4
5
3.2 增强 for 循环
语法结构： 增强 for 循环主要用于遍历数组或集合中的元素，它简化了对数组和集合的遍历操作，不需要手动操作索引。
for (元素类型 元素变量 : 数组或集合) {
// 循环体，对每个元素执行的代码
}
执行流程： 增强 for 循环会依次将数组或集合中的每个元素赋值给元素变量，然后执行循环体，直到遍历完所有元素。
代码示例：
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
// 遍历数组
int[] numbers = {
1, 2, 3};
for (int num : numbers) {
System.out.println("数字：" + num);
}
// 遍历集合
List<String> fruit = new ArrayList<>();
fruit.add("Apple");
fruit.add("Banana");
fruit.add("Orange");
for (String name : fruit) {
System.out.println("水果：" + name);
}
}
}
运行结果：
数字：1
数字：2
数字：3
水果：Apple
水果：Banana
水果：Orange
3.3 for 循环的变体
在 Java 中，for 语句的三个部分都可以省略或根据需要进行灵活调整。
省略初始化表达式：
int i = 1;
for (; i <= 5; i++) {
System.out.println(i);
}
在这种情况下，循环控制变量 i 在 for 循环外部进行初始化。
省略布尔表达式：
for (int i = 1; ; i++) {
if (i > 5) {
break;
}
System.out.println(i);
}
如果省略布尔表达式，循环将变为 死循环，因为循环没有终止条件，所以需要在循环体中使用 break 语句来终止循环。
省略迭代表达式：
for (int i = 1; i <= 5; ) {
System.out.println(i);
i++;
}
在这种情况下，迭代操作可以在循环体内部完成。
3.4 for 循环总结
- 基本 for 循环适用于需要精确控制循环次数和循环变量的场景。
- 增强 for 循环适用于简单遍历数组或集合中的元素，无需关注索引。
- for 语句的变体提供了更大的灵活性，可以根据具体需求进行调整。
四、while 循环
在 Java 中，while 循环是一种常用的循环结构，用于重复执行特定的代码块，直到指定的条件不再满足为止。Java 中有两种形式的 while 循环：基本 while 循环和 do-while 循环，下面为你详细介绍这两种循环。
4.1 基本 while 循环
语法结构：
while (布尔表达式) {
// 循环体，需要重复执行的代码
}
执行流程：
- 首先计算布尔表达式的值。
- 如果布尔表达式的值为 true，则执行循环体中的代码。
- 循环体执行完毕后，再次计算布尔表达式的值。
- 重复步骤 2 和 3，直到布尔表达式的值为 false，此时退出循环。
代码示例：
public class Main {
public static void main(String[] args) {
int i = 1;
// 打印 1 到 5 的数字
while (i <= 5) {
System.out.println(i);
i++;
}
}
}
运行结果：
1
2
3
4
5
4.2 do-while 循环
语法结构：
do {
// 循环体，需要重复执行的代码
} while (布尔表达式);
执行流程：
- 首先执行一次循环体中的代码。
- 循环体执行完毕后，计算布尔表达式的值。
- 如果布尔表达式的值为 true，则再次执行循环体；如果为 false，则退出循环。
代码示例：
public class Main {
public static void main(String[] args) {
int i = 1;
do {
System.out.println(i);
i++;
} while (i <= 5);
}
}
运行结果：
1
2
3
4
5
4.3 两者的区别
- 执行顺序：基本 while 循环先判断条件，再执行循环体；而 do-while 循环先执行一次循环体，再判断条件。这意味着 do-while 循环至少会执行一次循环体，而基本 while 循环在条件一开始就不满足时，循环体一次都不会执行。
- 适用场景：当你需要确保循环体至少执行一次时，使用 do-while 循环；当你不确定循环体是否需要执行时，使用基本 while 循环。
注意事项：
- 如果布尔表达式的值始终为 true，循环将永远不会结束，形成死循环，所以我们要确保对影响布尔表达式结果的变量进行适当的更新，让其在一定条件下会变为 false，以避免死循环。
五、跳转关键字
在 Java 中，break、continue 和 return 是三个用于控制程序流程的关键字，它们在不同的场景下发挥着重要作用，以下为你详细介绍：
5.1 break 关键字
作用： break 主要用于终止当前所在的循环或者 switch 语句的执行，使程序跳出该结构，继续执行后续的代码。
在循环中的使用示例：
public class Main {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
// 当 i 等于 5 时，终止循环
if (i == 5) {
break;
}
System.out.println(i);
}
System.out.println("循环结束");
}
}
运行结果：
1
2
3
4
循环结束
在 switch 语句中的使用示例：
public class Main {
public static void main(String[] args) {
int num = 2;
switch (num) {
case 1:
System.out.println("数字是 1");
break;
case 2:
System.out.println("数字是 2");
break; // 跳出 switch 语句
case 3:
System.out.println("数字是 3");
break;
default:
System.out.println("其他数字");
}
System.out.println("switch 语句结束");
}
}
运行结果：
数字是 2
switch 语句结束
5.2 continue 关键字
作用： continue 用于跳过当前循环中剩余的代码，直接进入下一次循环迭代。也就是说，当执行到 continue 语句时，程序会忽略循环体中 continue 语句之后的代码，直接回到循环的起始处，重新判断循环条件，决定是否继续下一次迭代。
代码示例：
public class Main {
public static void main(String[] args) {
for (int i = 1; i <= 10; i++) {
// 当 i 为偶数时，跳过本次循环的剩余代码，进入下一次迭代
if (i % 2 == 0) {
continue;
}
System.out.println(i);
}
System.out.println("循环结束");
}
}
运行结果：
1
3
5
7
9
循环结束
5.3 return 关键字
作用： return 关键字有两个主要作用：
- 从方法中返回值： 当方法有返回类型时，return 语句用于将计算结果返回给调用该方法的地方。
- 终止方法的执行： 无论方法是否有返回类型，return 语句都会使方法立即结束执行，返回到调用该方法的位置。
有返回值的方法示例：
public class ReturnValueExample {
public static int add(int a, int b) {
return a + b; // 返回 a 和 b 的和
}
public static void main(String[] args) {
int result = add(3, 5);
System.out.println("两数之和为: " + result);
}
}
在 add 方法中，return a + b; 语句将 a 和 b 的和作为结果返回给调用者，main 方法中调用 add 方法并接收返回值存储在 result 变量中。
无返回值的方法示例：
public class ReturnVoidExample {
public static void printNumbers(int limit) {
for (int i = 1; i <= limit; i++) {
if (i == 5) {
return; // 当 i 等于 5 时，终止方法的执行
}
System.out.println(i);
}
}
public static void main(String[] args) {
printNumbers(10);
System.out.println("方法调用结束");
}
}
在 printNumbers 方法中，当 i 等于 5 时，return 语句被执行，方法立即结束，不再继续执行后续的循环和代码，程序回到 main 方法继续执行输出语句。
5.4 总结
- break 用于终止当前所在的循环或 switch 语句。
- continue 用于跳过当前循环的剩余代码，进入下一次循环迭代。
- return 用于从方法中返回值并终止方法的执行。
六、方法
在 Java 中，方法（Method）是一段可重复使用的代码块，它将特定的功能封装起来，提高了代码的复用性和可维护性。以下从多个方面详细介绍 Java 方法：
6.1 方法的定义
方法的定义包含几个关键部分，基本语法如下：
修饰符 返回值类型 方法名(参数列表) {
// 方法体
return 返回值; // 如果返回值类型不为 void，则需要有返回语句
}
- 修饰符： 可选部分，用于指定方法的访问权限和其他特性，如 public、private、protected、static 等。
- 返回值类型： 指定方法执行完毕后返回的数据类型。如果方法不返回任何值，则使用 void 关键字。
- 方法名： 是方法的标识符，遵循 Java 的命名规范，通常使用驼峰命名法。
- 参数列表： 可以包含零个或多个参数，多个参数之间用逗号分隔，每个参数由参数类型和参数名组成。
- 方法体： 包含了实现方法功能的具体代码。
- 返回值： 如果返回值类型不为 void，则方法体中必须有 return 语句，用于返回与返回值类型匹配的数据。
6.2 方法的分类
- 无参无返回值方法：
public class Main {
// 无参无返回值方法
public static void printHello() {
System.out.println("Hello!");
}
public static void main(String[] args) {
printHello();
}
}
运行结果
Hello!
- 有参无返回值方法：
public class Main {
// 有参无返回值方法
public static void printSum(int a, int b) {
int sum = a + b;
System.out.println("两数之和为: " + sum);
}
public static void main(String[] args) {
printSum(3, 5);
}
}
运行结果
两数之和为: 8
- 无参有返回值方法：
public class Main {
// 无参有返回值方法
public static int getRandomNumber() {
return (int) (Math.random() * 100);
}
public static void main(String[] args) {
int randomNum = getRandomNumber();
System.out.println("随机数为: " + randomNum);
}
}
运行结果
随机数为: 84
- 有参有返回值方法：
public class Main {
// 有参有返回值方法
public static int multiply(int a, int b) {
return a * b;
}
public static void main(String[] args) {
int result = multiply(4, 6);
System.out.println("两数之积为: " + result);
}
}
运行结果：
两数之积为: 24
6.3 方法的调用
方法定义好后，需要在其他地方调用才能执行其功能。方法调用通过方法名和传递相应的参数来完成。
public class Main {
public static void main(String[] args) {
int num1 = 5;
int num2 = 3;
// 调用有参有返回值方法
int product = multiply(num1, num2);
System.out.println("乘积: " + product);
}
public static int multiply(int a, int b) {
return a * b;
}
}
运行结果：
乘积: 15
6.5 方法的重载
方法重载是指在一个类中可以定义多个具有相同方法名，但参数列表不同的方法。
编译器会根据调用方法时传递的参数类型和数量来决定调用哪个具体的方法。
public class Main {
public static int add(int a, int b) {
return a + b;
}
public static double add(double a, double b) {
return a + b;
}
public static int add(int a, int b, int c) {
return a + b + c;
}
public static void main(String[] args) {
int sum1 = add(3, 5);
double sum2 = add(2.5, 3.7);
int sum3 = add(1, 2, 3);a
System.out.println("整数和: " + sum1);
System.out.println("双精度和: " + sum2);
System.out.println("三个整数和: " + sum3);
}
}
运行结果：
整数和: 8
双精度和: 6.2
三个整数和: 6
6.6 方法的递归
递归是指方法直接或间接地调用自身。递归通常用于解决可以分解为相同类型子问题的问题，如计算阶乘、斐波那契数列等。
public class RecursionExample {
// 计算 n 的阶乘
public static int factorial(int n) {
if (n == 0 || n == 1) {
return 1;
} else {
return n * factorial(n - 1);
}
}
public static void main(String[] args) {
int num = 5;
int result = factorial(num);
System.out.println(num + " 的阶乘是: " + result);
}
}
在 factorial 方法中，通过不断调用自身来计算阶乘，直到满足终止条件。
七、数组
在 Java 中，数组是一种用于存储多个相同类型元素的容器。它具有固定的长度，一旦创建，其长度就不能再改变。下面将从数组的声明、初始化、访问、遍历、多维数组以及常见操作等方面详细介绍 Java 数组。
7.1 数组的声明
在 Java 中，声明数组有两种常见的语法形式：
// 第一种形式
数据类型[] 数组名;
// 第二种形式
数据类型 数组名[];
通常推荐使用第一种风格，因为它更能清晰地表明这是一个数组类型。第二种形式风格是来自 C/C++ 语言 ，在 Java 中采用是为了让 C/C++ 程序员能够快速理解 Java 语言。例如：
// 声明一个整型数组
int[] numbers;
// 声明一个字符串数组
String[] names;
7.2 数组的初始化
数组声明后，需要进行初始化才能使用。初始化可以分为静态初始化和动态初始化。
静态初始化： 指在声明数组的同时为数组元素赋值，由系统自动确定数组的长度。语法如下：
数据类型[] 数组名 = {
元素 1, 元素 2, ..., 元素 n};
代码示例：
// 静态初始化一个整型数组
int[] numbers = {
1, 2, 3, 4, 5};
// 静态初始化一个字符串数组
String[] names = {
"张三", "李四", "王五"};
动态初始化： 指先指定数组的长度，系统会为数组元素分配默认值，之后可以再为数组元素赋值。语法如下：
数据类型[] 数组名 = new 数据类型[数组长度];
代码示例：
// 动态初始化一个整型数组，长度为 5
int[] numbers = new int[5];
// 为数组元素赋值
numbers[0] = 1;
numbers[1] = 2;
7.3 数组的访问
数组元素可以通过下标（索引）来访问，下标从 0 开始，最大下标为数组长度减 1。语法如下：
数组名[下标];
代码示例：
public class Main {
public static void main(String[] args) {
// 静态初始化数组
int[] numbers = {
1, 2, 3, 4, 5};
// 访问数组的第一个元素
int firstElement = numbers[0];
// 访问数组的第三个元素
int thirdElement = numbers[2];
System.out.println("第一个元素：" + firstElement);
System.out.println("第二个元素：" + thirdElement);
}
}
运行结果：
第一个元素：1
第二个元素：3
7.4 数组的遍历
遍历数组是指依次访问数组中的每个元素。常见的遍历方式有 for 循环、增强 for 循环 。
使用 for 循环遍历：
public class Main {
public static void main(String[] args) {
int[] numbers = {
1, 2, 3, 4, 5};
for (int i = 0; i < numbers.length; i++) {
System.out.println(numbers[i]);
}
}
}
运行结果：
1
2
3
4
5
使用增强 for 循环遍历：
public class Main {
public static void main(String[] args) {
int[] numbers = {
1, 2, 3, 4, 5};
for (int num : numbers) {
System.out.println(num);
}
}
}
运行结果：
1
2
3
4
5
增强 for 循环更简洁，适用于只需要依次访问数组元素，而不需要使用下标的场景。
7.5多维数组
Java 支持多维数组，最常见的是二维数组。二维数组可以看作是数组的数组。
二维数组的声明和初始化：
// 静态初始化
int[][] matrix = {
{
1, 2, 3},
{
4, 5, 6},
{
7, 8, 9}
};
``
// 动态初始化
int[][] matrix2 = new int[3][3];
二维数组的访问和遍历:
public class Main {
public static void main(String[] args) {
int[][] matrix = {
{
1, 2, 3}, {
4, 5, 6}, {
7, 8, 9}};
// 访问二维数组的元素
int element = matrix[1][2]; // 访问第二行第三列的元素
// 遍历二维数组
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
System.out.print(matrix[i][j] + " ");
}
System.out.println();
}
}
}
运行结果：
1 2 3
4 5 6
7 8 9
7.6 注意事项
-
数组下标越界：访问数组元素时，下标必须在有效范围内（0 到数组长度减 1），否则会抛出 ArrayIndexOutOfBoundsException 异常。
-
数组长度固定：数组一旦创建，其长度就不能改变。如果需要动态调整长度，可以考虑使用 Java 的集合类（如 ArrayList）。
八、结语
这篇文章大概 13000 字，学习的时候细心一点，多敲多练多想就好。如果有什么问题，欢迎在评论区中留言评论。
至此，本文结束，如果这篇文章对您有所帮助，希望可以点赞、收藏加关注，感谢。