【JAVA】从0到1上手Java 18，超详细教程来袭！

一、Java 18 初印象

二、准备工作很重要

2.1 安装前的系统环境要求

2.2 不同操作系统的安装步骤

2.2.1 Windows 系统

2.2.2 macOS 系统

2.2.3 Linux 系统（以 Ubuntu 为例）

2.3 验证安装是否成功

三、基础语法大揭秘

3.1 变量声明与数据类型

3.2 运算符

3.3 流程控制语句

四、新特性全解析

4.1 简单 Web 服务器

4.2 新的文本块语法

4.3 模式匹配增强

五、面向对象编程实战

5.1 类和对象的创建与使用

5.2 封装：数据的隐藏与保护

5.3 继承：代码复用的利器

5.4 多态：同一接口，不同实现

六、常见问题与解决

6.1 安装问题

6.2 语法错误

6.3 新特性使用误区

6.4 类路径问题

6.5 内存溢出问题

七、总结与展望

一、Java 18 初印象

在 Java 的漫长发展历程中，每一个新版本的发布都像是为开发者们开启了一扇通往新世界的大门，带来全新的功能与优化，Java 18 也不例外。自 1995 年 Java 1.0 发布以来，Java 凭借其 “一次编写，到处运行” 的特性，在编程语言的舞台上占据了重要的一席之地。从最初的简单语法到后来不断完善的类库、强大的内存管理以及卓越的并发处理能力，Java 始终紧跟时代步伐，满足着开发者日益增长的需求。

Java 18 作为 Java 发展道路上的一个重要里程碑，它承载着无数开发者的期待，带来了一系列令人眼前一亮的新特性和改进。这些变化不仅提升了 Java 语言本身的性能和安全性，更为开发者们提供了更加便捷、高效的开发方式。无论是经验丰富的资深开发者，还是刚刚踏入 Java 编程领域的新手，都能从 Java 18 中发现许多值得探索和学习的地方。它就像是一座蕴藏着丰富宝藏的矿山，等待着我们去挖掘和利用。接下来，就让我们一同深入 Java 18 的世界，揭开它神秘的面纱，看看它究竟为我们带来了哪些惊喜吧！

二、准备工作很重要

在开启 Java 18 的探索之旅前，我们得先把基础打牢，完成安装前的准备工作以及 Java 18 的安装与环境配置。这就好比建造高楼，坚实的地基是关键，而正确的安装和配置就是我们在 Java 18 编程世界里稳步前行的基石。

2.1 安装前的系统环境要求

在安装 Java 18 之前，确保你的系统满足以下基本要求，以免在安装过程中遇到不必要的阻碍：

操作系统：Windows 7 及以上版本、macOS 10.8 及以上版本、各种主流 Linux 发行版（如 Ubuntu、CentOS 等）都支持 Java 18 的安装。不过，为了获得更好的性能和稳定性，建议使用较新的操作系统版本。

硬件资源：至少需要 512MB 的内存，以保证 Java 程序在运行时有足够的空间来存储数据和执行操作。同时，确保系统有至少 300MB 的可用磁盘空间，用于存放 Java 18 的安装文件和相关组件。

2.2 不同操作系统的安装步骤

接下来，让我们详细了解一下在不同操作系统上安装 Java 18 的具体步骤。

2.2.1 Windows 系统

下载 JDK 18：打开你常用的浏览器，访问 Oracle 官方网站的 Java 下载页面（Java Downloads | Oracle）。在下载页面中，找到适用于 Windows 系统的 JDK 18 安装包，根据你的系统是 32 位还是 64 位，选择对应的版本进行下载。这里强烈推荐下载最新的长期支持（LTS）版本，以获取更好的稳定性和安全性。

安装 JDK 18：下载完成后，找到下载的安装包（通常是一个.exe 文件），双击运行它。在安装向导界面中，点击 “下一步” 开始安装。在安装过程中，你可以选择默认的安装路径，也可以点击 “更改” 按钮选择其他路径进行安装。不过要注意，安装路径不要包含中文或特殊字符，以免后续出现兼容性问题。选择好安装路径后，继续点击 “下一步”，等待安装完成。

配置环境变量：安装完成后，还需要配置系统的环境变量，让系统能够找到 Java 的安装路径。具体步骤如下：

右键点击 “此电脑”，选择 “属性”。

在弹出的窗口中，点击左侧的 “高级系统设置”。

在 “系统属性” 窗口的 “高级” 选项卡中，点击 “环境变量” 按钮。

在 “系统变量” 区域中，点击 “新建” 按钮，创建一个新的系统变量。变量名输入 “JAVA_HOME”，变量值为你刚才安装 JDK 18 的路径，例如 “C:Program FilesJavajdk – 18” 。

找到系统变量中的 “Path” 变量，点击 “编辑” 按钮。在弹出的编辑环境变量窗口中，点击 “新建”，然后输入 “% JAVA_HOME%in”，将其添加到 Path 变量中。这样，系统就能够在命令行中找到 Java 的可执行文件了。

如果你还需要使用 Java 的其他功能，比如运行 Java 小程序，还可以创建一个名为 “CLASSPATH” 的系统变量，变量值为 “.;% JAVA_HOME%libdt.jar;% JAVA_HOME%lib ools.jar” 。注意，这里的 “.” 表示当前目录。

2.2.2 macOS 系统

下载 JDK 18：同样在 Oracle 官方网站的 Java 下载页面，找到适用于 macOS 系统的 JDK 18 安装包，通常是一个.dmg 文件，点击下载。

安装 JDK 18：下载完成后，双击下载的.dmg 文件，打开安装器。按照安装向导的提示，一步步完成安装过程。安装过程中，你可以选择默认的安装位置，也可以根据自己的需求进行更改。

配置环境变量：打开终端应用程序，通过以下步骤配置环境变量：

如果你使用的是 Bash shell，输入命令 “nano ~/.bash_profile”；如果你使用的是 Zsh shell，输入命令 “nano ~/.zshrc” ，这两个命令分别用于编辑对应的配置文件。

在打开的文件中，添加以下两行代码：

export JAVA_HOME=$(/usr/libexec/java_home)

export PATH=$JAVA_HOME/bin:$PATH

这两行代码的作用是设置 JAVA_HOME 环境变量，使其指向 Java 的安装路径，并将 Java 的 bin 目录添加到系统的 PATH 变量中，这样在终端中就可以直接执行 Java 相关的命令了。

添加完成后，按下 “Ctrl + O” 保存文件，然后按下 “Ctrl + X” 退出编辑器。

最后，在终端中输入命令 “source ~/.bash_profile”（如果使用的是 Bash shell）或 “source ~/.zshrc”（如果使用的是 Zsh shell），使刚才的配置生效。

2.2.3 Linux 系统（以 Ubuntu 为例）

更新系统：在安装 Java 18 之前，先确保你的系统是最新的，这可以通过在终端中执行以下命令来完成：

sudo apt update

sudo apt upgrade

这两条命令会更新系统的软件包列表，并将已安装的软件包更新到最新版本。

2. 安装 Java 18：Ubuntu 系统中可以通过包管理器来安装 Java 18，有两种常见的方法：

方法一：使用 SDKMAN!：SDKMAN! 是一个用于管理软件开发工具包版本的命令行工具，使用它可以方便地安装和切换不同版本的 Java。

首先，在终端中执行以下命令安装 SDKMAN!：

curl -s "https://get.sdkman.io" | bash

安装完成后，根据提示重启终端，或者执行命令 “source “$HOME/.sdkman/bin/sdkman – init.sh”” 来激活 SDKMAN!。

激活后，使用以下命令安装 Java 18：

sdk install java 18.0.2 - zulu

这里的 “18.0.2 – zulu” 是 Java 18 的一个具体版本，你可以根据实际情况选择最新的可用版本。

方法二：手动下载安装：如果不想使用 SDKMAN!，也可以直接从 Oracle 官网下载 Java 18 的安装包进行手动安装。

访问 Oracle JDK 18 下载页面，根据你的系统选择合适的安装包，对于大多数 Linux 发行版，选择.tar.gz 格式的文件。

下载完成后，使用以下命令解压安装包：

sudo mkdir -p /usr/lib/jvm

sudo tar -xzf jdk - 18_linux - x64_bin.tar.gz -C /usr/lib/jvm

这里将安装包解压到了 “/usr/lib/jvm” 目录下，你可以根据自己的需求选择其他目录。

解压完成后，还需要配置环境变量，编辑 “~/.bashrc” 或 “~/.profile” 文件，在文件末尾添加以下内容（请根据实际解压后的目录名替换 “jdk – 18.0.2”）：

export JAVA_HOME=/usr/lib/jvm/jdk - 18.0.2

export PATH=$JAVA_HOME/bin:$PATH

添加完成后，保存文件并退出编辑器，然后执行命令 “source ~/.bashrc” 或 “source ~/.profile” 使配置生效。

2.3 验证安装是否成功

完成 Java 18 的安装和环境配置后，我们需要验证一下是否安装成功。打开命令行工具（Windows 下是命令提示符，macOS 和 Linux 下是终端），输入以下命令：

java -version

如果安装成功，你将会看到类似以下的输出信息，显示当前安装的 Java 18 的版本号和其他相关信息：

openjdk version "18.0.2" 2022 - 07 - 19

OpenJDK Runtime Environment (build 18.0.2+9 - Ubuntu - 0ubuntu122.04)

OpenJDK 64 - Bit Server VM (build 18.0.2+9 - Ubuntu - 0ubuntu122.04, mixed mode, sharing)

除了检查 Java 的版本号，还可以通过检查 Java 编译器是否安装成功来进一步验证。在命令行中输入以下命令：

javac -version

如果安装成功，会显示 Java 编译器的版本号，例如：

javac 18.0.2

如果在验证过程中出现 “命令未找到” 或其他错误信息，可能是环境变量配置不正确或者安装过程中出现了问题。此时，可以仔细检查环境变量的配置是否正确，或者重新安装 Java 18。

通过以上步骤，我们就完成了 Java 18 在不同操作系统上的安装和环境配置，并且验证了安装的正确性。接下来，就可以正式开启 Java 18 的学习和使用之旅了！

三、基础语法大揭秘

基础语法是 Java 编程的根基，它就像建造高楼大厦的一砖一瓦，只有熟练掌握这些基础，才能构建出复杂而强大的 Java 程序。接下来，我们将深入探讨 Java 18 的基础语法，包括变量声明、数据类型、运算符、流程控制语句等，并对比旧版本，看看 Java 18 在基础语法上有哪些改进或变化。

3.1 变量声明与数据类型

在 Java 中，变量是存储数据的容器，就好比一个个小盒子，每个盒子都有自己的名字（变量名）和可以装的东西（数据类型）。变量声明时需要指定数据类型，Java 18 支持的基本数据类型与之前版本一致，包括：

整数类型：byte（8 位）、short（16 位）、int（32 位）、long（64 位）。例如，int age = 20;声明了一个名为age的整型变量，并初始化为 20 。在 Java 中，整数类型的默认类型是int，如果需要声明long类型的变量，需要在数值后面加上L或l，如long bigNumber = 10000000000L; 。

浮点类型：float（单精度，32 位）、double（双精度，64 位）。float类型的变量需要在数值后面加上F或f，如float pi = 3.14f; ，而double类型是 Java 中浮点型的默认类型，例如double salary = 5000.5; 。由于浮点数在计算机中存储的特殊性，在进行浮点数比较时，需要特别注意精度问题，一般不建议直接使用==进行比较，而是使用BigDecimal等类来处理高精度的浮点数运算。

字符类型：char（16 位），用于存储单个字符，例如char grade = 'A'; 。字符类型可以表示一个 Unicode 字符，其取值范围是u0000到uffff 。除了普通字符，还可以使用转义字符来表示一些特殊字符，如
表示换行，表示制表符等。

布尔类型：boolean，只有两个值true和false，用于逻辑判断。例如boolean isStudent = true; 。布尔类型不能与其他数据类型进行转换，它在条件判断、循环控制等语句中起着关键作用。

与旧版本相比，Java 18 在变量声明和数据类型方面并没有引入新的特性，但对类型推断进行了一些优化，使得代码更加简洁易读。例如，在使用var关键字进行局部变量类型推断时，Java 18 的类型推断能力更强，可以更准确地推断出变量的类型。var list = new ArrayList<String>(); ，这里var关键字让编译器自动推断出list的类型为ArrayList<String> ，避免了显式地写出冗长的类型声明。不过，使用var关键字时要注意，虽然代码简洁了，但也会在一定程度上降低代码的可读性，所以要根据实际情况合理使用，一般在类型显而易见的情况下使用var会使代码更加简洁优雅。

3.2 运算符

运算符是对数据进行操作的符号，Java 18 支持丰富的运算符，包括算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符等。

算术运算符：用于基本的数学运算，如加（+）、减（-）、乘（*）、除（/）、取余（%）。int result = 10 + 5; ，这里使用加法运算符计算出 10 和 5 的和并赋值给result变量。需要注意的是，在整数除法中，如果两个操作数都是整数，结果将是整数，会直接截断小数部分，如int quotient = 7 / 2; ，quotient的值为 3，而不是 3.5 。如果需要得到小数结果，其中一个操作数应该是浮点数类型。

关系运算符：用于比较两个值的大小关系，结果是布尔值。包括等于（==）、不等于（!=）、大于（>）、小于（<）、大于等于（>=）、小于等于（<=）。boolean isGreater = 10 > 5; ，这里使用大于运算符比较 10 和 5 的大小，结果isGreater为true 。在使用关系运算符时，要注意数据类型的一致性，不同类型的数据进行比较可能会得到意想不到的结果，并且要注意==和equals方法的区别，对于基本数据类型，使用==比较值是否相等，而对于引用数据类型，==比较的是对象的内存地址，要比较对象的内容是否相等，通常需要使用equals方法。

逻辑运算符：用于组合多个条件，结果也是布尔值。包括逻辑与（&&）、逻辑或（||）、逻辑非（!）。boolean canGoOut = isSunny && isWeekend; ，这里使用逻辑与运算符判断是否既天晴又在周末，如果两个条件都满足，canGoOut为true 。逻辑运算符具有短路特性，对于&&运算符，如果第一个条件为false，则不会再计算第二个条件；对于||运算符，如果第一个条件为true，则不会再计算第二个条件，这在一定程度上可以提高程序的执行效率。

位运算符：用于对二进制位进行操作，包括按位与（&）、按位或（|）、按位异或（^）、按位取反（~）、左移（<<）、右移（>>）、无符号右移（>>>）。int result = 5 & 3; ，这里对 5 和 3 进行按位与操作，先将 5 和 3 转换为二进制，5 的二进制是 101，3 的二进制是 011，按位与操作后得到 001，即结果为 1 。位运算符在一些底层编程、数据加密、图像处理等领域有广泛的应用，理解位运算符的工作原理对于优化程序性能和实现特定功能非常重要。

赋值运算符：用于将值赋给变量，最基本的赋值运算符是= ，还包括复合赋值运算符，如+=、-=、*=、/=、%=等。int num = 5; num += 3; ，这里先将 5 赋值给num变量，然后使用+=复合赋值运算符，相当于num = num + 3; ，最终num的值为 8 。复合赋值运算符可以使代码更加简洁，同时也提高了代码的可读性和编写效率。

Java 18 在运算符方面同样没有重大改变，但在一些细节上进行了优化，以提高代码的执行效率和安全性。在某些复杂的表达式中，编译器能够更智能地优化运算符的计算顺序，减少不必要的中间计算过程，从而提升程序的性能。在涉及整数溢出的情况下，Java 18 也增强了错误提示和处理机制，帮助开发者更快地发现和解决潜在的问题，确保程序在各种情况下都能稳定运行。

3.3 流程控制语句

流程控制语句用于控制程序的执行流程，就像交通规则一样，引导程序按照我们设定的路线运行。Java 18 支持的流程控制语句主要有条件语句（if – else、switch）、循环语句（for、while、do – while）和跳转语句（break、continue、return）。

条件语句：

if – else 语句：根据条件的真假来决定执行哪部分代码块。例如：

int score = 85;

if (score >= 90) {

System.out.println("Grade: A");

} else if (score >= 80) {

System.out.println("Grade: B");

} else if (score >= 70) {

System.out.println("Grade: C");

} else {

System.out.println("Grade: F");

}

这段代码根据学生的成绩score判断等级，当score大于等于 90 时，输出Grade: A，以此类推。在使用if – else语句时，要注意条件的顺序和逻辑的准确性，避免出现逻辑错误导致程序运行结果不符合预期。

switch 语句：从 Java 14 开始，switch语句引入了一些新特性，Java 18 继续沿用并进行了优化，使其更加灵活和强大。新的switch语句支持使用yield关键字返回值，并且可以使用表达式作为case的条件。例如：

int day = 3;

String dayName = switch (day) {

case 1 -> "Monday";

case 2 -> "Tuesday";

case 3 -> "Wednesday";

default -> "Invalid day";

};

System.out.println(dayName);

这里使用新的switch语法，根据day的值返回对应的星期名称，代码更加简洁明了。switch语句在处理多分支条件时，比if – else语句更加清晰和高效，特别是当分支条件较多时，使用switch语句可以提高代码的可读性和维护性。

循环语句：

for 循环：用于已知循环次数的情况，语法为for (初始化表达式; 条件表达式; 更新表达式) { 循环体 } 。例如：

for (int i = 1; i <= 10; i++) {

System.out.println("Number: " + i);

}

这段代码会从 1 循环到 10，依次输出Number: 1到Number: 10 。在使用for循环时，要注意初始化表达式、条件表达式和更新表达式的正确编写，确保循环能够按照预期的次数执行，避免出现死循环或循环次数错误的情况。

while 循环：用于在条件满足时不断循环执行代码块，语法为while (条件表达式) { 循环体 } 。例如：

int i = 1;

while (i <= 10) {

System.out.println("Number: " + i);

i++;

}

这段代码与上面的for循环功能相同，也是从 1 循环到 10 。while循环适用于循环次数不确定，只根据某个条件来决定是否继续循环的情况，在使用时要注意条件表达式的变化，确保循环能够在适当的时候结束，避免出现死循环导致程序卡死。

do – while 循环：与while循环类似，但它先执行一次循环体，然后再判断条件表达式是否成立，语法为do { 循环体 } while (条件表达式); 。例如：

int j = 1;

do {

System.out.println("Number: " + j);

j++;

} while (j <= 10);

这种循环结构保证了循环体至少会被执行一次，在某些需要先执行一些操作，然后再根据条件判断是否继续循环的场景中非常有用，比如用户登录验证，先要求用户输入用户名和密码，然后再验证输入是否正确，如果不正确则继续提示用户输入，直到输入正确为止。

跳转语句：

break 语句：用于跳出当前循环或switch语句。例如：

for (int i = 1; i <= 10; i++) {

if (i == 5) {

break;

}

System.out.println("Number: " + i);

}

这段代码会输出Number: 1到Number: 4，当i等于 5 时，遇到break语句，跳出循环。break语句可以使程序在满足特定条件时提前结束循环，提高程序的执行效率，在多层循环嵌套的情况下，break语句默认跳出当前所在的循环，如果需要跳出外层循环，可以使用标签（label）来指定跳出的循环。

continue 语句：用于跳过本次循环的剩余代码，直接开始下一次循环。例如：

for (int i = 1; i <= 10; i++) {

if (i % 2 == 0) {

continue;

}

System.out.println("Number: " + i);

}

这段代码会输出所有的奇数，当i是偶数时，遇到continue语句，跳过本次循环的System.out.println(“Number: ” + i);语句，直接开始下一次循环。continue语句可以帮助我们在循环中根据特定条件跳过某些不需要处理的情况，使程序的逻辑更加清晰和高效。

return 语句：用于从方法中返回值，并结束方法的执行。例如：

public static int add(int a, int b) {

return a + b;

}

在这个方法中，return语句返回a和b的和，并结束add方法的执行。return语句在方法中非常重要，它决定了方法的返回值和执行结果，对于有返回值类型的方法，必须使用return语句返回一个符合方法返回值类型的值，否则会编译错误；对于返回值类型为void的方法，也可以使用return语句提前结束方法的执行，不过此时return语句后面不能跟返回值。

Java 18 在流程控制语句方面的改进主要体现在代码的可读性和简洁性上，新的语法和特性使得开发者能够更清晰地表达程序的逻辑，减少代码的冗余。在实际编程中，合理运用这些流程控制语句可以使程序更加灵活、高效地运行，满足各种复杂的业务需求。

四、新特性全解析

Java 18 带来了一系列令人兴奋的新特性，这些新特性犹如魔法工具，为我们的开发工作注入了新的活力，极大地提升了开发效率和代码质量。接下来，让我们深入探索这些新特性，并通过实际代码示例来感受它们的魅力。

4.1 简单 Web 服务器

在 Java 18 中，引入了一个简单的 Web 服务器，这为开发者在进行原型设计、临时编码和测试时提供了极大的便利。它就像是一个便捷的小助手，无需复杂的配置，就能快速搭建起一个静态文件服务器。假设我们正在开发一个小型的 Web 项目，需要快速预览前端页面效果，使用 Java 18 的简单 Web 服务器就能轻松实现。只需在命令行中输入一行简单的命令，就能启动一个服务器，将指定目录下的静态文件展示出来。下面是一个使用 Java 代码启动简单 Web 服务器的示例：

import java.net.InetSocketAddress;

import java.nio.file.Path;

import com.sun.net.httpserver.SimpleFileServer;

import static com.sun.net.httpserver.SimpleFileServer.OutputLevel;

public class WebServerExample {

public static void main(String[] args) throws Exception {

// 创建一个简单文件服务器，绑定到8000端口，使用当前目录作为文件根目录，输出详细日志

var server = SimpleFileServer.createFileServer(new InetSocketAddress(8000), Path.of("."), OutputLevel.VERBOSE);

server.start();

System.out.println("Server started on port 8000");

}

在这个示例中，我们使用SimpleFileServer.createFileServer方法创建了一个简单的 Web 服务器，并将其绑定到本地的 8000 端口，使用当前目录作为文件根目录。通过server.start()方法启动服务器后，我们就可以在浏览器中访问http://localhost:8000来查看服务器上的静态文件了。这个简单 Web 服务器虽然功能相对简单，不支持动态内容和复杂的交互逻辑，但在许多场景下，它的快速搭建和便捷使用特性，能够帮助我们节省大量的时间和精力，快速验证想法和进行初步的开发测试。

4.2 新的文本块语法

新的文本块语法是 Java 18 的又一亮点，它为处理多行字符串提供了更加简洁和直观的方式。在以往的 Java 版本中，当我们需要处理包含大量换行、缩进和特殊字符的字符串时，往往需要使用繁琐的转义字符和字符串拼接操作，这不仅容易出错，而且代码的可读性很差。而 Java 18 的文本块语法就像是为我们提供了一个 “所见即所得” 的编辑器，让我们可以直接在代码中编写多行字符串，无需担心转义字符的困扰。比如，当我们需要在 Java 代码中定义一个 HTML 模板字符串时，使用新的文本块语法可以使代码变得更加清晰易懂：

String html = """

<!DOCTYPE html>

<html>

<body>

<h1>Welcome to My Website</h1>

<p>This is a simple paragraph.</p>

</body>

</html>

""";

System.out.println(html);

在这个例子中，我们使用三个双引号（”””）来定义一个文本块，其中的内容就是我们需要的 HTML 字符串。可以看到，文本块中的内容与我们平常编写 HTML 代码的格式完全一致，不需要额外的转义字符，代码的可读性大大提高。而且，文本块还会自动处理缩进和换行，使得代码更加整洁美观。除了 HTML，在处理 SQL 语句、JSON 字符串等多行文本时，新的文本块语法同样能发挥巨大的优势，让我们的代码编写更加高效和愉悦。

4.3 模式匹配增强

模式匹配增强是 Java 18 对switch语句的一次重大升级，它使得switch语句能够更加智能地处理不同类型的数据和条件。在传统的switch语句中，我们只能对基本数据类型或枚举类型进行匹配，而在 Java 18 中，通过模式匹配增强，switch语句可以对对象的类型、属性等进行匹配，并且可以结合yield关键字返回不同的结果。这一特性在处理复杂的业务逻辑和数据处理时非常有用，能够使代码更加简洁和易读。假设我们有一个表示图形的类继承体系，包括圆形、矩形和三角形，现在需要根据不同的图形类型计算它们的面积，使用 Java 18 的模式匹配增强后的switch语句可以这样实现：

// 定义图形接口

interface Shape {

}

// 圆形类

class Circle implements Shape {

private double radius;

public Circle(double radius) {

this.radius = radius;

}

public double getRadius() {

return radius;

}

// 矩形类

class Rectangle implements Shape {

private double width;

private double height;

public Rectangle(double width, double height) {

this.width = width;

this.height = height;

}

public double getWidth() {

return width;

}

public double getHeight() {

return height;

}

// 三角形类

class Triangle implements Shape {

private double base;

private double height;

public Triangle(double base, double height) {

this.base = base;

this.height = height;

}

public double getBase() {

return base;

}

public double getHeight() {

return height;

}

public class ShapeAreaCalculator {

public static void main(String[] args) {

Shape circle = new Circle(5);

Shape rectangle = new Rectangle(4, 6);

Shape triangle = new Triangle(3, 8);

System.out.println(calculateArea(circle));

System.out.println(calculateArea(rectangle));

System.out.println(calculateArea(triangle));

}

public static double calculateArea(Shape shape) {

return switch (shape) {

case Circle c -> Math.PI * c.getRadius() * c.getRadius();

case Rectangle r -> r.getWidth() * r.getHeight();

case Triangle t -> 0.5 * t.getBase() * t.getHeight();

default -> 0;

};

}

在这个示例中，我们定义了一个Shape接口以及三个实现类Circle、Rectangle和Triangle 。在calculateArea方法中，使用模式匹配增强后的switch语句，根据传入的Shape对象的实际类型，匹配不同的case分支，并计算相应的面积。可以看到，代码非常简洁明了，通过模式匹配，我们能够直接在switch语句中处理不同类型的对象，避免了繁琐的类型判断和强制转换操作，大大提高了代码的可读性和维护性。这种模式匹配增强的特性，为我们在处理复杂数据结构和业务逻辑时提供了更加强大、灵活的工具，让我们能够以更加优雅的方式编写 Java 代码。

五、面向对象编程实战

面向对象编程（OOP）是 Java 的核心编程范式，它将数据和操作数据的方法封装在一起，形成对象，通过对象之间的交互来完成复杂的任务。Java 18 在面向对象编程方面虽然没有引入全新的语法特性，但凭借其强大的类库和优化的编译器，为开发者提供了更加高效、灵活的编程体验。接下来，我们将结合 Java 18 深入探讨面向对象编程的核心概念，包括类和对象、封装、继承、多态，并通过具体代码示例展示如何在 Java 18 中更好地运用这些特性进行程序设计。

5.1 类和对象的创建与使用

类是对象的模板，它定义了对象的属性和行为。在 Java 中，使用class关键字来定义类，例如：

public class Dog {

// 属性

private String name;

private int age;

// 构造方法

public Dog(String name, int age) {

this.name = name;

this.age = age;

}

// 方法

public void bark() {

System.out.println(name + " is barking.");

}

public void showInfo() {

System.out.println("Name: " + name + ", Age: " + age);

}

在这个例子中，我们定义了一个Dog类，它有两个属性name和age，以及两个方法bark和showInfo 。private关键字用于修饰属性，使其只能在类内部被访问，这体现了封装的思想。构造方法Dog(String name, int age)用于在创建对象时初始化属性。

创建对象时，使用new关键字调用构造方法，例如：

public class Main {

public static void main(String[] args) {

Dog myDog = new Dog("Buddy", 3);

myDog.bark();

myDog.showInfo();

}

在main方法中，我们创建了一个Dog类的对象myDog，并调用了它的bark和showInfo方法。通过这种方式，我们可以根据类创建多个对象，每个对象都有自己独立的属性值，它们之间通过方法调用进行交互，实现各种功能。

5.2 封装：数据的隐藏与保护

封装是面向对象编程的重要特性之一，它将对象的属性和实现细节隐藏起来，只对外提供公共的访问方法。通过封装，我们可以提高代码的安全性和可维护性，防止外部代码对对象内部数据的非法访问和修改。在 Java 中，使用访问修饰符（private、default、protected、public）来实现封装。

private修饰符是最严格的访问级别，被其修饰的属性和方法只能在类内部访问。例如，在上面的Dog类中，name和age属性被声明为private，外部代码无法直接访问它们，只能通过类提供的公共方法（如showInfo方法）来获取属性值。如果外部代码需要修改属性值，可以通过提供setter方法来实现，同时在setter方法中可以添加一些逻辑判断，确保属性值的合法性。

public class Dog {

private String name;

private int age;

public Dog(String name, int age) {

this.name = name;

this.age = age;

}

// Getter和Setter方法

public String getName() {

return name;

}

public void setName(String name) {

if (name != null &&!name.isEmpty()) {

this.name = name;

} else {

System.out.println("Invalid name. Name cannot be null or empty.");

}

public int getAge() {

return age;

}

public void setAge(int age) {

if (age > 0) {

this.age = age;

} else {

System.out.println("Invalid age. Age must be a positive number.");

}

public void bark() {

System.out.println(name + " is barking.");

}

public void showInfo() {

System.out.println("Name: " + name + ", Age: " + age);

}

在这个改进后的Dog类中，我们添加了getName、setName、getAge和setAge方法，通过这些方法，外部代码可以安全地访问和修改Dog对象的属性。在setName和setAge方法中，我们添加了参数验证逻辑，确保传入的属性值符合要求，从而保护了对象内部数据的完整性。

5.3 继承：代码复用的利器

继承是指一个子类可以继承其父类的属性和方法，从而实现代码的复用。在 Java 中，使用extends关键字来表示继承关系。例如，我们可以定义一个Poodle类，它继承自Dog类：

public class Poodle extends Dog {

// Poodle类特有的属性

private String furColor;

public Poodle(String name, int age, String furColor) {

// 调用父类的构造方法

super(name, age);

this.furColor = furColor;

}

// Poodle类特有的方法

public void run() {

System.out.println(name + " is running with " + furColor + " fur.");

}

// 重写父类的方法

@Override

public void bark() {

System.out.println(name + " is barking softly.");

}

在这个例子中，Poodle类继承自Dog类，它不仅拥有Dog类的所有属性和方法，还可以定义自己特有的属性（如furColor）和方法（如run）。在Poodle类的构造方法中，使用super(name, age)调用父类的构造方法，以初始化从父类继承的属性。同时，Poodle类重写了父类的bark方法，提供了自己的实现，这体现了多态的特性。

通过继承，我们可以避免重复编写代码，提高开发效率。当需要创建一个新的类，且这个类与已有的类有部分相同的属性和方法时，就可以考虑使用继承来实现。在 Java 18 中，继承的使用方式与之前版本相同，但在代码编写过程中，我们可以结合新的语法特性（如文本块、模式匹配等），使代码更加简洁和易读。

5.4 多态：同一接口，不同实现

多态是指同一个方法调用在不同的对象上会产生不同的行为。在 Java 中，多态主要通过方法重写和接口实现来体现。方法重写是指子类重新定义父类中已有的方法，当通过父类引用调用这个方法时，实际执行的是子类重写后的方法。接口实现则是指一个类实现一个或多个接口，通过接口引用调用接口中定义的方法时，实际执行的是实现类中实现的方法。

继续以上面的Dog和Poodle类为例，我们可以在Main类中展示多态的效果：

public class Main {

public static void main(String[] args) {

Dog dog1 = new Dog("Max", 5);

Dog dog2 = new Poodle("Bella", 2, "White");

dog1.bark();

dog2.bark();

}

在这个例子中，dog1是Dog类的对象，dog2是Poodle类的对象，但它们都被声明为Dog类型。当调用bark方法时，dog1会执行Dog类中定义的bark方法，而dog2会执行Poodle类中重写后的bark方法，这就是多态的体现。通过多态，我们可以编写更加灵活和可扩展的代码，在运行时根据对象的实际类型来决定执行哪个方法，提高代码的通用性和适应性。

在 Java 18 中，模式匹配增强为多态的实现提供了更强大的工具。在处理复杂的对象类型判断和方法调用时，可以使用模式匹配后的switch语句，根据对象的具体类型进行不同的操作，使代码更加简洁和高效。

面向对象编程是 Java 编程的核心，通过类和对象、封装、继承、多态等特性，我们可以构建出结构清晰、可维护性高、可扩展性强的 Java 程序。Java 18 为我们提供了更好的编程环境和工具，让我们能够更加高效地运用面向对象编程思想，解决各种实际问题。

六、常见问题与解决

在使用 Java 18 的过程中，难免会遇到各种问题，这些问题就像前进道路上的小石子，虽然不大，但如果不及时解决，也会影响我们的开发进度。下面，我们就来总结一些常见问题及对应的解决方法，希望能帮助大家顺利解决问题，继续在 Java 18 的编程世界里畅行无阻。

6.1 安装问题

问题描述：下载的安装包无法正常运行，或者安装过程中出现错误提示，如 “安装程序无法启动”“缺少必要的依赖项” 等。

解决方案：首先，检查下载的安装包是否完整，可通过官方网站重新下载，确保文件没有损坏。其次，确认系统是否满足 Java 18 的安装要求，如操作系统版本、硬件资源等。如果提示缺少依赖项，根据提示信息安装相应的依赖软件。在 Windows 系统中，如果安装包无法启动，可尝试以管理员身份运行安装程序。

6.2 语法错误

问题描述：编写 Java 代码时，出现语法错误，如 “非法字符”“缺少分号”“未定义的变量” 等，导致代码无法编译通过。

解决方案：仔细检查代码中出现错误的位置，根据错误提示信息，修正语法错误。对于初学者来说，很容易因为疏忽而遗漏分号、括号不匹配等问题，所以在编写代码时要养成严谨的编程习惯。如果是未定义的变量，要确保变量已经声明和初始化。同时，利用好集成开发环境（IDE）的语法检查功能，如 Eclipse、IntelliJ IDEA 等，它们能够实时提示语法错误，帮助我们及时发现和解决问题。

6.3 新特性使用误区

问题描述：在使用 Java 18 的新特性时，由于对新特性的理解不够深入，导致使用不当，出现各种奇怪的问题。在使用新的文本块语法时，可能会错误地在文本块中使用转义字符，或者在模式匹配增强的switch语句中，条件判断逻辑错误。

解决方案：深入学习和理解 Java 18 新特性的使用方法和原理，查阅官方文档和相关教程，了解每个新特性的具体使用场景和注意事项。在使用新特性前，可以先编写一些简单的测试代码，验证自己的理解是否正确。对于复杂的新特性，如模式匹配增强，建议多参考实际的代码示例，逐步掌握其使用技巧。

6.4 类路径问题

问题描述：在运行 Java 程序时，出现 “类无法找到”“找不到主类” 等错误，这通常是由于类路径（classpath）配置不正确导致的。

解决方案：检查类路径的配置是否正确，确保程序所需的类文件和依赖库都在正确的类路径下。在命令行中运行 Java 程序时，可以使用-classpath或-cp参数来指定类路径。例如：java -classpath.;lib/* MainClass ，其中 “.” 表示当前目录，“lib/*” 表示lib目录下的所有 jar 包。如果使用 IDE，要确保项目的构建路径配置正确，添加了所需的依赖库。

6.5 内存溢出问题

问题描述：程序在运行过程中，出现 “OutOfMemoryError” 错误，提示内存不足，这可能是由于程序中存在内存泄漏或者对象创建过多，导致堆内存耗尽。

解决方案：首先，检查程序中是否存在内存泄漏的情况，例如，对象被创建后没有及时释放引用，导致对象无法被垃圾回收器回收。可以使用 Java 的内存分析工具，如 VisualVM、Eclipse Memory Analyzer（MAT）等，来分析堆内存的使用情况，找出占用大量内存的对象和可能存在的内存泄漏点。其次，如果是因为对象创建过多导致内存溢出，可以考虑优化程序的算法和数据结构，减少不必要的对象创建。另外，也可以通过调整 Java 虚拟机（JVM）的堆内存大小参数，如-Xms（初始堆大小）和-Xmx（最大堆大小），来增加程序可用的内存。例如：java -Xms512m -Xmx1024m MainClass ，将初始堆大小设置为 512MB，最大堆大小设置为 1024MB 。