一、HelloWorld 程序概述
HelloWorld 程序简介
HelloWorld 程序是编程领域中最基础、最经典的入门示例。它通常是一个简单的程序，功能是在屏幕上输出 “Hello, World!” 或类似的欢迎信息。这个程序的主要目的是展示一门编程语言的基本语法和运行方式，帮助初学者快速上手。
为什么选择 HelloWorld 作为第一个程序？
简单直观：HelloWorld 程序通常只有几行代码，易于理解。验证环境：通过运行 HelloWorld 程序，可以确认开发环境（如 JDK、IDE）是否正确配置。快速反馈：程序运行后会立即显示输出结果，让初学者获得成就感。
HelloWorld 程序在 Java 中的实现
以下是 Java 语言中的 HelloWorld 程序示例：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
代码解析
public class HelloWorld：
定义一个名为 HelloWorld 的公共类。在 Java 中，文件名必须与公共类名一致（这里是 HelloWorld.java）。 public static void main(String[] args)：
这是 Java 程序的入口方法。JVM 会从这里开始执行程序。 System.out.println("Hello, World!");：
调用 System.out 对象的 println 方法。将字符串 “Hello, World!” 输出到控制台，并换行。
运行 HelloWorld 程序的步骤
将代码保存为 HelloWorld.java 文件。打开终端/命令行，导航到文件所在目录。编译程序：javac HelloWorld.java（生成 HelloWorld.class 字节码文件）。运行程序：java HelloWorld（注意不要加 .class 后缀）。
常见问题与注意事项
大小写敏感：
Java 是大小写敏感的语言，System 不能写成 system。 类名与文件名必须一致：
如果类声明为 public class HelloWorld，文件名必须是 HelloWorld.java。 缺少 main 方法：
如果没有正确的 main 方法，程序将无法运行，会报错：Error: Main method not found in class HelloWorld。 中文乱码问题：
如果输出中文出现乱码，可能是编码问题。可以在编译时指定编码：javac -encoding UTF-8 HelloWorld.java。
变体示例
不换行输出：
System.out.print("Hello, World!"); // 注意是 print 不是 println
多行输出：
System.out.println("Hello,");
System.out.println("World!");
使用格式化输出：
System.out.printf("Hello, %s!%n", "World");
HelloWorld 程序虽然简单，但它包含了 Java 程序的基本结构，是学习任何编程语言的起点。通过这个程序，可以逐步扩展到更复杂的功能和概念。
HelloWorld 程序的历史意义
1. 起源与首次亮相
HelloWorld 程序最早出现在 1972 年，由贝尔实验室的 Brian Kernighan 在《A Tutorial Introduction to the B Language》中首次使用（当时用 B 语言编写）。1978 年，他在《The C Programming Language》一书中沿用此示例，使其成为 C 语言的标志性入门程序。
2. 编程教育的“第一课”
极简性：仅需几行代码即可展示语言的核心语法（如输出函数、程序结构）。即时反馈：运行后直接显示结果，帮助初学者建立“编写-运行-验证”的闭环认知。跨语言通用性：几乎所有编程语言（Java、Python、C++等）都将其作为标准示例。
3. 文化象征意义
程序员社群的“仪式感”：被视为学习新语言或工具时的“成人礼”。技术文档的惯例：官方文档常以 HelloWorld 演示环境配置和基础语法。调试的起点：用于验证开发环境是否正常工作（如 Java 中检查 JDK 安装）。
4. 对 Java 的特别意义
1995 年 Java 发布时，HelloWorld 程序因其跨平台特性被广泛演示：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
这段代码直观体现了 Java 的：
面向对象（class 声明）程序入口（main 方法）标准输出（System.out）
5. 争议与局限性
过度简化：可能让初学者低估实际项目的复杂性。文化差异：部分非英语地区教程会改用本地化输出（如“你好，世界！”）。
Java 中 HelloWorld 的基本结构
Java 的 HelloWorld 程序是最基础的入门示例，它展示了 Java 程序的基本组成部分。以下是一个标准的 HelloWorld 程序代码：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
1. 类定义（Class Definition）
public class HelloWorld：
public 是访问修饰符，表示这个类可以被其他任何类访问。class 是关键字，用于声明一个类。HelloWorld 是类名，必须与文件名一致（即文件必须保存为 HelloWorld.java）。类是 Java 程序的基本组织单元，所有代码都必须包含在类中。
2. 主方法（Main Method）
public static void main(String[] args)：
public：表示该方法可以被 JVM（Java 虚拟机）调用。static：表示该方法属于类本身，而不是类的实例。void：表示该方法没有返回值。main：是方法的名称，JVM 执行程序时会从这里开始。String[] args：是一个字符串数组参数，用于接收命令行参数（可选）。主方法是 Java 程序的入口点，没有它程序无法运行。
3. 输出语句（Output Statement）
System.out.println("Hello, World!");：
System 是 Java 的一个内置类，提供系统相关功能。out 是 System 类的一个静态成员，代表标准输出流（通常是控制台）。println 是方法名，用于打印一行文本并换行。"Hello, World!" 是要输出的字符串内容。
4. 代码块（Code Blocks）
类和方法的内容都用大括号 {} 包裹，表示代码块的范围。
类的代码块包含成员变量和方法。方法的代码块包含具体的执行语句。
5. 注意事项
文件名必须与公共类名一致：
如果类声明为 public class HelloWorld，文件名必须是 HelloWorld.java。 大小写敏感：
Java 区分大小写，main 不能写成 Main 或 MAIN。 分号结尾：
每条语句必须以分号 ; 结束。 方法必须放在类中：
不能独立于类之外定义方法。
6. 扩展：使用 printf 格式化输出
除了 println，还可以使用 printf 进行格式化输出：
public class HelloWorld {
public static void main(String[] args) {
System.out.printf("Hello, %s!%n", "World");
}
}
%s 是字符串占位符，%n 是换行符（跨平台兼容）。
7. 常见错误
缺少主方法：
如果没有 main 方法，程序会报错：Error: Main method not found in class HelloWorld。 拼写错误：
如将 System 写成 system，会导致编译错误。 文件名与类名不匹配：
如果类名是 HelloWorld，但文件名为 hello.java，会报错：class HelloWorld is public, should be declared in a file named HelloWorld.java。
8. 总结
HelloWorld 程序虽然简单，但涵盖了 Java 程序的核心结构：
类定义（class）。主方法（main）。输出语句（System.out.println）。代码块（{}）。
这是学习 Java 的第一步，后续所有复杂程序都是在此基础上扩展的。
二、编写 HelloWorld 程序
开发环境准备（JDK安装）
JDK 是什么？
JDK（Java Development Kit）是 Java 开发工具包，包含运行和开发 Java 程序所需的工具和库。它由以下几个核心组件组成：
JRE（Java Runtime Environment）：运行 Java 程序的环境。编译器（javac）：将 Java 源代码（.java）编译为字节码（.class）。调试工具（jdb）：用于调试 Java 程序。其他工具（如 javadoc、jar）：生成文档、打包程序等。
为什么需要安装 JDK？
运行 Java 程序：必须安装 JDK 或 JRE 才能执行 Java 程序。开发 Java 程序：编写和编译 Java 代码需要 JDK 提供的工具（如 javac）。调试和优化：JDK 提供调试工具（如 jdb）和性能分析工具（如 jvisualvm）。
如何安装 JDK？
下载 JDK：
访问 Oracle JDK 官网 或 OpenJDK 官网。选择适合你操作系统的版本（Windows、macOS、Linux）。 安装 JDK：
Windows：
运行下载的 .exe 安装程序，按照向导完成安装。默认安装路径通常为 C:\Program Files\Java\jdk-
双击下载的 .dmg 文件，拖拽到 Applications 文件夹。 Linux：
使用包管理器安装（如 sudo apt install openjdk-17-jdk）。或手动解压 .tar.gz 文件并配置环境变量。 验证安装：
打开终端（Windows：cmd；macOS/Linux：Terminal）。输入以下命令检查 JDK 版本：java -version
javac -version
如果显示版本号（如 17.0.1），则安装成功。
配置环境变量（可选但推荐）
为了让系统在任何目录下都能识别 java 和 javac 命令，需要配置环境变量：
Windows：
右键“此电脑” → “属性” → “高级系统设置” → “环境变量”。在“系统变量”中新建 JAVA_HOME，值为 JDK 安装路径（如 C:\Program Files\Java\jdk-17）。编辑 Path 变量，添加 %JAVA_HOME%\bin。 macOS/Linux： 编辑 ~/.bashrc 或 ~/.zshrc 文件，添加：export JAVA_HOME=/path/to/jdk
export PATH=$JAVA_HOME/bin:$PATH
然后运行 source ~/.bashrc 生效。
常见问题
java 命令可用，但 javac 不可用：
可能只安装了 JRE 而非 JDK，需重新安装 JDK。 版本冲突：
如果安装了多个 JDK，可通过 update-alternatives（Linux）或手动调整 PATH 顺序解决。 权限问题（Linux/macOS）：
确保 JDK 安装目录的权限正确（如 chmod +x /path/to/jdk/bin/*）。
示例：验证安装
# 检查 Java 运行时版本
java -version
# 检查编译器版本
javac -version
# 输出示例：
# java version "17.0.1" 2021-10-19 LTS
# javac 17.0.1
注意事项
选择长期支持（LTS）版本：如 JDK 8、11、17，适合生产环境。避免安装到带空格的路径：如 C:\Program Files 可能引发问题，可改为 C:\Java\jdk-17。定期更新：修复安全漏洞和性能问题。
创建 Java 源文件
基本概念
Java 源文件是以 .java 为扩展名的纯文本文件，包含 Java 程序的源代码。它是 Java 程序开发的起点，需要通过 Java 编译器（javac）编译为字节码文件（.class 文件）后才能运行。
文件命名规则
主文件名：必须与文件中定义的 public 类名完全一致（包括大小写）。
例如：public class HelloWorld 必须保存在 HelloWorld.java 文件中。 扩展名：必须为 .java。命名规范：建议使用大驼峰式（PascalCase），如 MyFirstProgram.java。
文件内容结构
一个基础的 Java 源文件通常包含以下部分：
// 类定义（必须与文件名一致）
public class HelloWorld {
// 主方法（程序入口）
public static void main(String[] args) {
// 代码逻辑
System.out.println("Hello, World!");
}
}
创建步骤
选择文本编辑器：
推荐：IntelliJ IDEA、Eclipse、VS Code 等 IDE基础工具：记事本、Notepad++、Sublime Text 等 保存文件：
确保文件编码为 UTF-8（避免中文乱码）注意操作系统是否隐藏了文件扩展名（需显示 .java 扩展名） 文件存放位置：
建议为每个项目创建独立目录示例路径：C:\myproject\HelloWorld.java
注意事项
大小写敏感：
Java 严格区分大小写，HelloWorld.java ≠ helloworld.java public 类限制：
每个 .java 文件最多只能有一个 public 类可以有多个非 public 类（但不建议） 编码问题：
如果包含中文，编译时需指定编码：javac -encoding UTF-8 HelloWorld.java
文件系统限制：
避免使用空格或特殊字符（如 #, &）命名文件Windows 系统路径不要包含中文
验证示例
创建 HelloWorld.java 文件：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("文件创建成功！");
}
}
通过命令行验证：
javac HelloWorld.java
java HelloWorld
应输出：文件创建成功！
main 方法详解
概念定义
main 方法是 Java 程序的入口点，是 JVM（Java 虚拟机）执行程序的起点。它是一个静态方法，必须按照特定的语法格式定义，否则 JVM 将无法识别并运行程序。
标准语法
public static void main(String[] args) {
// 程序逻辑代码
}
组成部分解析
public 访问修饰符，表示该方法可以被 JVM 在任何地方访问。
static 静态修饰符，表示该方法属于类而非对象，JVM 无需创建类的实例即可调用。
void 返回类型，表示 main 方法不返回任何值。
main 方法名，必须严格拼写为 main（区分大小写）。
String[] args 命令行参数数组，用于接收从命令行传入的参数。args 是约定俗成的参数名，但可以自定义（如 String[] arguments）。
使用场景
所有可独立运行的 Java 程序必须包含 main 方法。用于初始化程序、调用其他方法或处理命令行输入。
示例代码
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
// 打印命令行参数
for (String arg : args) {
System.out.println("参数: " + arg);
}
}
}
常见误区
拼写错误
错误示例：Main、MAIN 或 mian。JVM 仅识别全小写的 main。 缺少 static 或 public
错误示例：void main(String[] args) 或 static void main(String[] args)。必须同时包含 public 和 static。 参数类型错误
错误示例：main(String args) 或 main(String... args)（尽管可变参数语法允许，但建议使用标准数组形式）。 非 void 返回类型
错误示例：public static int main(String[] args)。main 必须声明为 void。
注意事项
一个类可以有多个 main 方法（通过重载），但只有 public static void main(String[]) 会被 JVM 调用。在 IDE 中运行程序时，可通过配置传递命令行参数到 args 数组。
System.out.println 的使用
概念定义
System.out.println 是 Java 中用于向标准输出（通常是控制台）打印一行文本的方法。它是 System 类中的一个静态成员，属于 PrintStream 类型。println 方法会在输出内容后自动添加一个换行符。
语法结构
System.out.println([参数]);
参数：可以是字符串、数字、布尔值、对象等。如果省略参数，则输出一个空行。
使用场景
调试程序：打印变量值或程序执行状态。用户交互：向用户显示提示信息或程序输出结果。日志记录：在简单程序中替代日志框架，记录关键信息。
示例代码
打印字符串：
System.out.println("Hello, World!");
输出：
Hello, World!
打印变量：
int age = 25;
System.out.println("Age: " + age);
输出：
Age: 25
打印多个值：
String name = "Alice";
double score = 95.5;
System.out.println("Name: " + name + ", Score: " + score);
输出：
Name: Alice, Score: 95.5
打印空行：
System.out.println();
常见误区或注意事项
性能问题：频繁调用 System.out.println 会影响程序性能，尤其是在循环中。生产环境中建议使用日志框架（如 Log4j、SLF4J）。字符串拼接：使用 + 运算符拼接字符串时，可能会产生多个临时对象，影响性能。对于复杂拼接，可以使用 StringBuilder。格式化输出：如果需要更复杂的输出格式（如对齐、小数点位数等），可以使用 System.out.printf 或 String.format。System.out.printf("Name: %-10s, Score: %.2f%n", name, score);
跨平台换行符：println 会自动使用平台相关的换行符（\n 或 \r\n），无需手动处理。
相关方法
虽然你要求聚焦于 println，但为了完整性，以下是 System.out 的其他常用方法（简要提及）：
print：输出内容但不换行。printf：格式化输出。flush：强制刷新输出缓冲区。
代码缩进与格式规范
概念定义
代码缩进与格式规范是指在编写代码时，通过统一的空格、制表符（Tab）或换行等规则，使代码结构清晰、层次分明的一种约定。缩进通常用于表示代码块（如类、方法、循环、条件语句等）的嵌套关系，而格式规范则包括空格使用、换行规则、大括号位置等细节。
使用场景
代码块嵌套：如 if-else、for、while、方法体等。类与方法定义：类成员、方法之间的对齐。参数与表达式：长参数列表或复杂表达式的换行对齐。团队协作：统一团队代码风格，提升可读性。
常见规范（以Java为例）
缩进：
通常使用 4个空格（Java官方推荐）或 1个Tab（需团队统一）。示例：public class HelloWorld {
public static void main(String[] args) {
if (true) {
System.out.println("Hello"); // 缩进4空格
}
}
}
大括号位置：
K&R风格（Java主流）：左大括号 { 不换行，右大括号 } 独占一行。if (condition) {
// code
}
空格规则：
运算符两侧加空格：int sum = a + b;逗号后加空格：method(arg1, arg2);关键字后加空格：if (condition) 换行规则：
每行代码不超过80-120字符（视团队约定）。长表达式或参数列表换行时，后续行对齐：String message = "Hello, "
+ "World!"; // 对齐上一行的起始位置
常见误区与注意事项
混用空格与Tab：
避免同时使用空格和Tab缩进，可能导致不同编辑器显示混乱。建议IDE设置为“用空格替代Tab”。 过度缩进：
嵌套过深时（如超过4层），应考虑重构代码。 忽略格式工具：
使用IDE自动格式化（如IntelliJ的Ctrl+Alt+L）或插件（Checkstyle、Spotless）。 对齐牺牲可读性：
示例（不推荐）：int a = 1; // 过度对齐
String name = "Bob";
为什么重要？
可读性：清晰的缩进能快速展示代码逻辑层次。维护性：统一风格降低团队协作成本。隐性错误：错误的缩进可能导致逻辑误解（如Python依赖缩进）。
示例对比
不规范代码：
public class HelloWorld{
public static void main(String[] args){
if(true){
System.out.println("Hello");}}}
规范代码：
public class HelloWorld {
public static void main(String[] args) {
if (true) {
System.out.println("Hello");
}
}
}
三、编译与运行
javac 编译命令详解
什么是 javac
javac 是 Java Development Kit (JDK) 中提供的 Java 编译器，用于将 .java 源文件编译为 .class 字节码文件。它是 Java 开发过程中最基础的工具之一。
基本语法
javac [options] [source files]
options: 可选的编译选项source files: 要编译的一个或多个 .java 源文件
常用编译选项
-d 指定输出目录
javac -d ./bin HelloWorld.java
将编译后的 .class 文件输出到指定目录如果目录不存在会自动创建如果不指定，默认输出到当前目录
-classpath (-cp) 指定类路径
javac -cp lib/*.jar;./bin HelloWorld.java
指定查找用户类文件的位置可以包含目录、JAR 文件或 ZIP 文件多个路径用分号(Windows)或冒号(Linux/Mac)分隔
-encoding 指定源文件编码
javac -encoding UTF-8 HelloWorld.java
指定源文件使用的字符编码如果不指定，使用平台默认编码
-source 指定源代码版本
javac -source 1.8 HelloWorld.java
指定接受的源代码版本例如 1.5, 1.6, 1.7, 1.8 等
-target 指定生成的类文件版本
javac -target 1.8 HelloWorld.java
指定生成的类文件将运行的 JVM 版本必须与 -source 版本兼容或相同
-verbose 输出详细编译信息
javac -verbose HelloWorld.java
输出编译器正在执行的操作包括加载的类、编译的方法等
-g 生成调试信息
javac -g HelloWorld.java
生成所有调试信息（行号、变量等）默认只生成行号和源文件信息
实际使用示例
编译单个文件
javac HelloWorld.java
编译多个文件
javac Main.java Util.java Constants.java
带包名的编译
javac -d ./bin com/example/HelloWorld.java
使用外部库编译
javac -cp lib/commons-lang3-3.12.0.jar -d ./bin src/com/example/App.java
常见问题与注意事项
类路径问题：最常见的错误是找不到类，确保正确设置 -classpath 参数
版本兼容性：-source 和 -target 版本要匹配，且不能高于运行环境的 JRE 版本
编码问题：如果源文件包含非ASCII字符，务必使用 -encoding 指定正确的编码
包目录结构：带包名的类必须放在对应的目录结构中
依赖顺序：javac 会自动解析依赖关系，不需要手动指定编译顺序
跨平台问题：Windows 和 Linux/Mac 的路径分隔符不同（; vs :）
高级用法
使用 @filename 从文件读取参数
javac @sourcefiles.txt
其中 sourcefiles.txt 包含：
-d bin
-cp lib/*.jar
src/com/example/App.java
src/com/example/Util.java
增量编译
javac -implicit:none HelloWorld.java
-implicit:none 不生成隐式引用的类文件可以用于精确控制编译范围
生成原生头文件（JNI开发）
javac -h ./include HelloWorld.java
为 native 方法生成 C/C++ 头文件
java 运行命令详解
基本语法
java [options]
参数说明
options（可选）：
JVM 选项：控制 Java 虚拟机的行为程序参数：传递给主类的参数 mainclass（必需）：
包含 main() 方法的完整类名需注意大小写敏感 args…（可选）：
传递给 main() 方法的命令行参数
常用 JVM 选项
选项说明-classpath 或 -cp指定类路径-D
类路径详解
默认值：当前目录 (.)指定方式：
-cp lib/a.jar:lib/b.jar（Linux/macOS）-cp lib/a.jar;lib/b.jar（Windows） 包含内容：
JAR 文件ZIP 文件包含类文件的目录
执行流程
启动 JVM加载指定的主类调用主类的 main() 方法执行程序逻辑程序结束，JVM 退出
常见错误
Error: Could not find or load main class
类名拼写错误类文件不在类路径中包声明与目录结构不匹配 Exception in thread "main" java.lang.NoClassDefFoundError
运行时缺少依赖的类 java.lang.UnsupportedClassVersionError
编译版本高于运行版本
示例
# 基本用法
java HelloWorld
# 指定类路径
java -cp "lib/*" com.example.Main
# 设置系统属性
java -Dconfig.path=/etc/myapp com.example.Main
# 传递参数
java Calculator add 5 3
注意事项
类名必须完全匹配（包括大小写）当使用包时，需确保目录结构与包名匹配在 Windows 上路径分隔符使用分号(😉，在 Unix-like 系统上使用冒号(😃通配符(*)只能用于 JAR 文件，不能用于类文件
常见编译错误及解决
1. 语法错误（Syntax Errors）
语法错误是最常见的编译错误之一，通常是由于代码不符合Java语法规则导致的。
常见类型及解决方法：
缺少分号（;） 示例：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World") // 缺少分号
}
}
解决方法： 在语句末尾添加分号。
括号不匹配 示例：
public class HelloWorld {
public static void main(String[] args {
System.out.println("Hello, World");
}
}
解决方法： 确保所有括号（{}、()）成对出现。
关键字拼写错误 示例：
public class HelloWorld {
publc static void main(String[] args) { // "public" 拼写错误
System.out.println("Hello, World");
}
}
解决方法： 检查并修正拼写错误。
2. 类型不匹配（Type Mismatch）
Java是强类型语言，变量类型必须与赋值或操作的类型一致。
常见类型及解决方法：
变量类型与赋值不匹配 示例：
public class HelloWorld {
public static void main(String[] args) {
int number = "123"; // 字符串赋值给整型变量
System.out.println(number);
}
}
解决方法： 修改变量类型或使用类型转换。
方法返回值类型不匹配 示例：
public class HelloWorld {
public static int greet() {
return "Hello"; // 返回字符串，但方法声明为返回int
}
}
解决方法： 修改方法返回值类型或返回值。
3. 未定义的变量或方法（Undefined Variable or Method）
使用未声明或未导入的变量、方法或类会导致编译错误。
常见类型及解决方法：
变量未声明 示例：
public class HelloWorld {
public static void main(String[] args) {
System.out.println(message); // "message" 未声明
}
}
解决方法： 声明变量或检查变量名拼写。
未导入类 示例：
public class HelloWorld {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in); // 未导入Scanner类
}
}
解决方法： 在文件顶部添加 import java.util.Scanner;。
4. 访问权限错误（Access Modifier Issues）
Java的访问修饰符（public、private、protected）限制了类、方法和变量的访问范围。
常见类型及解决方法：
访问私有成员 示例：public class HelloWorld {
private String message = "Hello";
public static void main(String[] args) {
System.out.println(message); // 无法访问私有变量
}
}
解决方法： 将变量改为 public 或通过公共方法访问。
5. 主方法签名错误（Main Method Signature Issues）
Java程序的入口是 main 方法，其签名必须严格符合规范。
常见错误：
签名不正确 示例：public class HelloWorld {
public static void main() { // 缺少String[]参数
System.out.println("Hello, World");
}
}
解决方法： 确保主方法签名为 public static void main(String[] args)。
6. 类名与文件名不匹配（Class Name vs. File Name）
在Java中，公共类（public class）的名称必须与文件名一致。
常见错误：
类名与文件名不一致 示例：// 文件名为 HelloWorld.java
public class Greeting { // 类名与文件名不一致
public static void main(String[] args) {
System.out.println("Hello, World");
}
}
解决方法： 修改类名或文件名，确保一致。
7. 其他常见错误
重复的变量或方法 示例：
public class HelloWorld {
public static void main(String[] args) {
int number = 10;
int number = 20; // 重复声明变量
}
}
解决方法： 修改变量名或删除重复声明。
未处理的异常 示例：
public class HelloWorld {
public static void main(String[] args) {
File file = new File("test.txt"); // 未处理FileNotFoundException
}
}
解决方法： 使用 try-catch 块或声明抛出异常。
常见运行错误及解决
1. 找不到或无法加载主类（Error: Could not find or load main class）
概念定义 该错误表示Java虚拟机（JVM）无法找到或加载指定的主类（包含main方法的类）。
常见原因
类名拼写错误：运行命令中的类名与实际类名不一致（区分大小写）。类文件未生成：未成功编译（.java文件未生成对应的.class文件）。包路径问题：类在包中但未正确指定包路径（如com.example.HelloWorld）。运行目录错误：未在正确的目录下执行命令（如类文件在bin目录但未切换到该目录）。
解决方法
检查类名拼写是否与public class名称完全一致（包括大小写）。确保已编译成功：javac HelloWorld.java
若类在包中，需使用全限定名运行：java com.example.HelloWorld
确认运行目录：
类文件在./bin目录时，需切换到bin的上级目录运行：java -cp bin HelloWorld
2. 主方法签名错误（Error: Main method not found in class）
概念定义 JVM要求主方法必须严格遵循public static void main(String[] args)的签名格式，否则无法识别。
常见错误形式
缺少static或public修饰符。参数类型非String[]（如误写为String args或String... args）。方法名拼写错误（如Main或mian）。
示例修正
// 正确写法
public static void main(String[] args) {
System.out.println("Hello World");
}
3. 编码问题（乱码或编译错误）
场景与表现
源代码中包含非ASCII字符（如中文注释或输出），但文件编码与编译环境不匹配。控制台输出乱码。
解决方法
编译时指定编码（如UTF-8）：javac -encoding UTF-8 HelloWorld.java
运行环境统一编码：
Windows（CMD）：chcp 65001 # 切换控制台为UTF-8
IDE中配置项目编码为UTF-8。
4. 类路径（Classpath）问题
概念定义 类路径（-cp参数）指定JVM查找类文件的路径。若未正确设置，会导致类加载失败。
常见场景
依赖第三方库但未包含在类路径中。类文件位于非默认目录（如out或target）。
解决方法 显式指定类路径运行：
java -cp .:lib/* HelloWorld # Linux/macOS
java -cp .;lib\* HelloWorld # Windows
5. 语法错误（编译时报错）
常见错误类型
缺少分号（;）或大括号（{}）。字符串引号未闭合（如"Hello）。使用未声明的变量。
示例修正
// 错误示例
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello) // 缺少引号和分号
}
}
// 正确示例
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello");
}
}
6. 权限问题（文件不可读写）
场景
尝试编译或运行的文件被其他程序占用。无权限访问目标目录。
解决方法
关闭占用文件的程序（如IDE）。以管理员权限运行终端（Windows）或使用sudo（Linux/macOS）。
classpath 环境变量
概念定义
classpath 是 Java 运行时环境（JRE）用来定位用户自定义类或第三方库的路径列表。它告诉 Java 虚拟机（JVM）在哪里查找编译后的 .class 文件和依赖的 JAR 包。
作用原理
编译阶段：javac 编译器通过 classpath 查找依赖的类。运行阶段：java 命令通过 classpath 加载主类及其依赖。
设置方式
1. 临时设置（命令行）
# Windows
java -cp .;lib\example.jar HelloWorld
# Linux/Mac
java -cp .:lib/example.jar HelloWorld
. 表示当前目录;（Windows）或 :（Linux/Mac）是路径分隔符
2. 永久设置（环境变量）
# Windows
set CLASSPATH=.;C:\path\to\lib\example.jar
# Linux/Mac
export CLASSPATH=.:/path/to/lib/example.jar
优先级规则
-cp/-classpath 命令行参数 > 环境变量 CLASSPATH未设置时默认包含当前目录（.）
常见误区
包含当前目录：新版 JDK 默认不包括 .，需显式添加路径分隔符：Windows 用分号，Linux/Mac 用冒号通配符使用：JAR 目录可以用 *（如 lib/*），但不能用于单个 JAR
最佳实践
# 推荐方式（显式指定）
java -cp "target/classes:lib/*" com.example.Main
# 避免（依赖默认 classpath）
java com.example.Main
调试技巧
// 查看实际加载的 classpath
System.out.println(System.getProperty("java.class.path"));
四、程序结构解析
public class 声明
概念定义
在Java中，public class声明用于定义一个公共类。public是访问修饰符，表示该类可以被任何其他类访问。class是关键字，用于声明一个类。类名应遵循Java命名规范，通常使用大驼峰命名法（如HelloWorld）。
语法结构
public class ClassName {
// 类体（成员变量、方法等）
}
使用场景
主类声明：包含main方法的类通常声明为public class，作为程序的入口。公共API：需要被其他包或模块访问的类。跨模块调用：在模块化系统中，public class可以被其他模块使用（需配合module-info.java导出）。
注意事项
文件名匹配：一个.java源文件中只能有一个public class，且文件名必须与public class的类名完全一致（包括大小写）。例如，public class HelloWorld必须保存在HelloWorld.java文件中。访问限制：如果没有显式声明为public，类默认是包私有（package-private），只能被同一包内的其他类访问。嵌套类：public可以用于嵌套类（内部类），此时外部类的访问权限不影响嵌套类的可见性。
示例代码
// 文件必须命名为HelloWorld.java
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
常见误区
多public类：在同一文件中声明多个public class会导致编译错误。// 错误示例：Multiple public classes in one file
public class A {}
public class B {}
文件名不符：若文件名与public class名不一致（如类名为HelloWorld但文件名为hello.java），编译会报错。冗余修饰符：在接口或枚举声明中使用public class是语法错误（应使用public interface或public enum）。
main 方法签名详解
1. 概念定义
main 方法是 Java 程序的入口点，是 JVM（Java 虚拟机）执行程序的起始位置。其标准签名如下：
public static void main(String[] args)
2. 签名组成解析
public
访问修饰符，表示该方法可以被 JVM 在任何地方调用。如果改为 private 或 protected，JVM 将无法找到入口，导致程序无法启动。 static
静态修饰符，表示该方法属于类而非对象实例。JVM 调用 main 时无需创建类的实例，直接通过类名访问。 void
返回类型，表示 main 方法不返回任何值。如果尝试返回 int 或其他类型，编译会报错。 main
方法名，必须严格拼写为 main（区分大小写）。修改为 Main 或 MAIN 会导致 JVM 无法识别入口。 String[] args
参数列表，接收命令行输入的字符串数组。参数名 args 是约定俗成的命名，但可以改为其他合法标识符（如 arguments）。
3. 使用场景
命令行参数传递 通过 args 数组接收外部输入，例如：
public static void main(String[] args) {
if (args.length > 0) {
System.out.println("第一个参数: " + args[0]);
}
}
运行命令：java HelloWorld "Hello"，输出结果为 第一个参数: Hello。
作为程序唯一入口 一个 Java 类可以包含多个方法，但只有 main 方法会被 JVM 自动调用。
4. 常见误区与注意事项
大小写敏感
Main 或 MAIN 不是合法的入口方法名。 参数类型必须为 String[]
使用 String... args（可变参数）是允许的，本质仍是数组：public static void main(String... args) // 等效于 String[]
但其他类型（如 int[] args）会导致 JVM 忽略该方法。 缺少 static 或 public
若遗漏 static，错误提示：找不到主方法。若遗漏 public，错误提示：main 方法不是 public 的。 重载 main 方法
可以定义其他同名方法（如 main(int x)），但只有标准签名的 main 会被 JVM 调用。
5. 示例代码
public class HelloWorld {
// 合法的 main 方法
public static void main(String[] args) {
System.out.println("Hello, World!");
for (String arg : args) {
System.out.println("参数: " + arg);
}
}
// 重载的 main 方法（不会被 JVM 调用）
public static void main(int num) {
System.out.println("数字: " + num);
}
}
6. 为什么必须这样设计？
public：确保 JVM 跨类加载器访问。static：避免实例化类的额外开销。String[]：统一处理命令行输入为字符串，简化 JVM 实现。
字符串字面量的定义
字符串字面量（String Literal）是指在Java源代码中直接使用双引号（"）括起来的字符序列。例如：
String greeting = "Hello, World!";
在这个例子中，"Hello, World!" 就是一个字符串字面量。字符串字面量在Java中是不可变的（immutable），一旦创建，其内容就不能被修改。
字符串字面量的特性
1. 字符串池（String Pool）
Java中的字符串字面量存储在字符串池（String Pool）中，这是一种特殊的内存区域。当创建一个字符串字面量时，JVM会首先检查字符串池中是否已存在相同的字符串。如果存在，则直接返回池中的引用；如果不存在，则在池中创建新的字符串对象并返回其引用。
示例：
String s1 = "Hello";
String s2 = "Hello"; // 复用字符串池中的"Hello"
System.out.println(s1 == s2); // 输出：true（引用相同）
2. 不可变性
字符串字面量是不可变的，任何对字符串的修改操作（如拼接、替换）都会生成一个新的字符串对象。
示例：
String s = "Hello";
s = s + " World"; // 创建新的字符串对象
System.out.println(s); // 输出：Hello World
字符串字面量的使用场景
直接赋值：用于初始化字符串变量。
String name = "Alice";
方法参数：作为方法的实参传递。
System.out.println("This is a message.");
常量定义：与 final 结合使用，定义不可变的字符串常量。
public static final String DEFAULT_NAME = "Unknown";
字符串拼接：与其他字符串或变量拼接。
String fullName = "Mr. " + "John Doe";
常见误区与注意事项
不要用 == 比较字符串内容 == 比较的是引用是否相同，而不是内容。应使用 equals() 方法。
String s1 = "Hello";
String s2 = new String("Hello");
System.out.println(s1 == s2); // false（引用不同）
System.out.println(s1.equals(s2)); // true（内容相同）
避免频繁拼接字符串 频繁拼接字符串会生成大量临时对象，影响性能。推荐使用 StringBuilder 或 StringBuffer。
StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" World");
String result = sb.toString();
转义字符的使用 字符串字面量中可能需要使用转义字符表示特殊符号，如 \n（换行）、\t（制表符）、\"（双引号）等。
String message = "Line 1\nLine 2";
String quote = "He said, \"Hello!\"";
示例代码
基本使用
public class StringLiteralDemo {
public static void main(String[] args) {
String s1 = "Hello"; // 字符串字面量
String s2 = "Hello"; // 复用字符串池中的对象
String s3 = new String("Hello"); // 强制创建新对象
System.out.println(s1 == s2); // true
System.out.println(s1 == s3); // false
System.out.println(s1.equals(s3)); // true
}
}
转义字符示例
public class EscapeSequenceDemo {
public static void main(String[] args) {
String path = "C:\\Program Files\\Java"; // 反斜杠转义
String multiLine = "Line 1\nLine 2\nLine 3";
System.out.println(path);
System.out.println(multiLine);
}
}
语句结束分号的作用
概念定义
在Java中，分号（;）是一个语句终止符，用于明确表示一条语句的结束。它告诉Java编译器当前语句已经完成，可以开始解析下一条语句。分号是Java语法中不可或缺的一部分，几乎所有独立的语句都需要以分号结尾。
使用场景
单行语句结束：每条独立的语句必须以分号结尾。
int age = 25; // 变量声明语句
System.out.println("Hello, World!"); // 方法调用语句
空语句：单独的分号可以表示一条空语句（不执行任何操作）。
; // 空语句，通常用于占位或某些特殊场景
for循环中的分隔：在for循环的初始化、条件和更新部分之间使用分号分隔。
for (int i = 0; i < 10; i++) {
System.out.println(i);
}
常见误区或注意事项
遗漏分号：忘记在语句末尾添加分号会导致编译错误。
int x = 10 // 错误：缺少分号
System.out.println(x);
多余分号：在代码块（如if、for、while等）后直接添加分号可能导致逻辑错误。
if (x > 5); { // 错误：分号导致if语句提前结束
System.out.println("x is greater than 5");
}
分号与代码块：代码块（用{}括起来的部分）不需要以分号结尾，但块内的每条语句仍需分号。
{
int y = 20; // 正确：语句需要分号
} // 正确：代码块不需要分号
分号与Lambda表达式：Lambda表达式的语句体如果是单条语句，可以省略分号；如果是多条语句，则需要分号。
Runnable r = () -> System.out.println("Hello"); // 单条语句可省略分号
Runnable r2 = () -> {
System.out.println("Hello"); // 多条语句需要分号
System.out.println("World");
};
示例代码
public class SemicolonExample {
public static void main(String[] args) {
// 单行语句结束
int a = 10;
System.out.println(a);
// 空语句
;
// for循环中的分号
for (int i = 0; i < 3; i++) {
System.out.println(i);
}
// 分号导致的逻辑错误示例
if (a > 5); {
System.out.println("This will always print");
}
}
}
代码注释的添加方式
单行注释
语法：使用双斜杠 // 开头，后跟注释内容。特点：
仅对当前行有效。适用于简短说明或临时注释代码。 示例：// 这是一行单行注释
int x = 10; // 声明并初始化变量x
多行注释
语法：以 /* 开头，以 */ 结尾，中间为注释内容。特点：
可跨越多行。适用于较长的说明或临时屏蔽代码块。 示例：/*
这是一个多行注释，
可以跨越多行。
*/
int y = 20;
文档注释
语法：以 /** 开头，以 */ 结尾，中间为注释内容。特点：
专为生成API文档设计（通过javadoc工具）。支持HTML标签和特殊标签（如@param、@return等）。 常见标签：
@param：描述方法参数。@return：描述返回值。@throws：描述可能抛出的异常。 示例：/**
* 计算两个整数的和。
*
* @param a 第一个加数
* @param b 第二个加数
* @return 两个参数的和
*/
public int add(int a, int b) {
return a + b;
}
注意事项
注释内容：
避免无意义的注释（如// 设置x为10）。重点解释“为什么”而非“做什么”（代码本身已体现逻辑）。 嵌套问题：
多行注释不可嵌套（/* /* 嵌套 */ */ 会报错）。单行注释可嵌套在多行注释中。 文档注释：
仅用于类、接口、方法、字段等公开元素的说明。私有方法通常不需要文档注释。
示例：HelloWorld中的注释
/**
* 我的第一个Java程序：HelloWorld
*/
public class HelloWorld {
/*
* main方法是程序入口
*/
public static void main(String[] args) {
// 打印Hello World到控制台
System.out.println("Hello World");
}
}
五、扩展知识
使用 IDE 运行 HelloWorld
什么是 IDE？
IDE（Integrated Development Environment，集成开发环境）是一种为开发者提供的软件工具，集成了代码编辑、编译、调试、运行等功能。常见的 Java IDE 包括 IntelliJ IDEA、Eclipse 和 NetBeans 等。
为什么使用 IDE 运行 HelloWorld？
虽然可以通过命令行编译和运行 Java 程序，但使用 IDE 可以：
简化操作流程（如自动编译、一键运行）。提供代码提示、语法高亮等辅助功能。便于调试和项目管理。
使用 IntelliJ IDEA 运行 HelloWorld 的步骤
1. 创建新项目
打开 IntelliJ IDEA，选择 New Project。选择 Java 作为项目类型，确保已配置 JDK（如未配置，需手动指定 JDK 安装路径）。点击 Next，然后 Finish 完成项目创建。
2. 创建 HelloWorld 类
在项目结构中，右键 src 文件夹，选择 New -> Java Class。输入类名 HelloWorld，按回车确认。在生成的 HelloWorld.java 文件中输入以下代码：public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, World!");
}
}
3. 运行程序
点击代码编辑器左侧的绿色三角形图标（或右键代码区域选择 Run 'HelloWorld.main()'）。IDE 会自动编译并运行程序，输出结果会显示在底部的 Run 窗口中：Hello, World!
使用 Eclipse 运行 HelloWorld 的步骤
1. 创建新项目
打开 Eclipse，选择 File -> New -> Java Project。输入项目名称（如 HelloWorldProject），点击 Finish。
2. 创建 HelloWorld 类
右键项目名，选择 New -> Class。在 Name 字段输入 HelloWorld，勾选 public static void main(String[] args) 选项。点击 Finish，Eclipse 会自动生成 main 方法。在 main 方法中添加代码：System.out.println("Hello, World!");
3. 运行程序
点击工具栏的绿色运行按钮（或右键文件选择 Run As -> Java Application）。输出结果会显示在 Console 视图中：Hello, World!
注意事项
JDK 配置：确保 IDE 中已正确配置 JDK，否则无法编译和运行。类名与文件名一致：public class HelloWorld 必须保存在 HelloWorld.java 文件中。主方法签名：main 方法的签名必须严格为 public static void main(String[] args)，否则程序无法启动。编码问题：如果代码中包含中文等非 ASCII 字符，需确保 IDE 和文件的编码一致（如 UTF-8）。
常见问题解决
找不到主类：检查是否正确定义了 main 方法，或尝试清理并重新编译项目。输出乱码：在 IDE 设置中调整运行环境的编码为 UTF-8。JDK 版本不匹配：确保项目使用的 JDK 版本与安装版本一致（如 JDK 11 或 17）。
示例截图（以 IntelliJ IDEA 为例）
创建项目时选择 JDK： (注：此处为示意链接，实际需替换为真实截图)运行结果展示：
输出多行信息的方法
在 Java 中，输出多行信息可以通过多种方式实现，以下是常见的几种方法：
使用 System.out.println() 多次调用
这是最简单直接的方法，每调用一次 System.out.println() 就会输出一行内容。
public class MultiLineOutput {
public static void main(String[] args) {
System.out.println("第一行信息");
System.out.println("第二行信息");
System.out.println("第三行信息");
}
}
使用换行符 \n
可以在一个字符串中使用换行符 \n 来实现多行输出。
public class MultiLineOutput {
public static void main(String[] args) {
System.out.println("第一行信息\n第二行信息\n第三行信息");
}
}
使用多行字符串（Java 15+）
从 Java 15 开始，支持文本块（Text Blocks），可以用 """ 来定义多行字符串。
public class MultiLineOutput {
public static void main(String[] args) {
System.out.println("""
第一行信息
第二行信息
第三行信息
""");
}
}
注意事项
跨平台换行符：不同操作系统对换行符的支持可能不同（Windows 是 \r\n，Unix/Linux 是 \n）。System.out.println() 会自动处理换行符，而手动使用 \n 时需注意兼容性。文本块缩进：使用文本块时，缩进会被保留，但可以通过调整 """ 的位置来控制缩进。性能考虑：如果输出大量多行信息，建议使用 StringBuilder 拼接字符串，避免频繁调用 System.out.println()。
转义字符的使用示例
什么是转义字符
转义字符是以反斜杠（\）开头，后跟一个或多个特定字符的组合，用于表示一些特殊含义或无法直接输入的字符。在Java中，转义字符主要用于字符串和字符常量中。
常见转义字符列表
以下是Java中常用的转义字符：
转义字符含义\t制表符（Tab）\n换行符（Newline）\r回车符（Carriage Return）\\反斜杠字符\"双引号字符\'单引号字符\b退格符（Backspace）\f换页符（Form Feed）
使用场景示例
1. 换行和制表符
public class EscapeExample {
public static void main(String[] args) {
System.out.println("第一行\n第二行");
System.out.println("姓名\t年龄\t性别");
System.out.println("张三\t25\t男");
}
}
输出：
第一行
第二行
姓名 年龄 性别
张三 25 男
2. 引号的转义
public class QuoteExample {
public static void main(String[] args) {
System.out.println("他说：\"你好，世界！\"");
System.out.println('\\'); // 输出单个反斜杠
}
}
输出：
他说："你好，世界！"
\
3. 文件路径表示
public class PathExample {
public static void main(String[] args) {
String path = "C:\\Program Files\\Java\\jdk1.8.0";
System.out.println("Java安装路径：" + path);
}
}
输出：
Java安装路径：C:\Program Files\Java\jdk1.8.0
常见误区与注意事项
路径分隔符：在Windows系统中，文件路径通常使用反斜杠，但在Java字符串中必须转义为\\。
正则表达式：正则表达式中也使用反斜杠，因此需要双重转义：
String regex = "\\d+"; // 匹配一个或多个数字
Unicode转义：Java还支持\uXXXX形式的Unicode转义，如\u0041表示大写字母’A’。
行终止符：不同操作系统对换行的表示不同（Windows:\r\n，Unix:\n），在跨平台开发时需要注意。
无效转义：使用未定义的转义字符（如\z）会导致编译错误。
国际化输出实现思路
国际化（Internationalization，简称 i18n）是指使程序能够适应不同语言和地区需求的过程。在 Java 中，国际化输出通常通过资源文件（Resource Bundle）和 Locale 类实现。
核心组件
ResourceBundle 用于加载特定语言环境的资源文件（.properties），存储键值对形式的文本内容。
文件命名规则：基础名_语言代码_国家代码.properties（如 messages_zh_CN.properties）。默认文件：基础名.properties（当找不到匹配的本地化文件时使用）。 Locale 表示特定的语言和地区（如 Locale.CHINA 或 new Locale("zh", "CN")）。
实现步骤
创建资源文件 在 resources 目录下定义不同语言的属性文件：
# messages_en_US.properties
greeting=Hello, {0}!
# messages_zh_CN.properties
greeting=你好，{0}！
加载资源并格式化输出 通过 ResourceBundle 和 MessageFormat 动态替换占位符：
import java.util.*;
import java.text.MessageFormat;
public class I18NDemo {
public static void main(String[] args) {
Locale locale = Locale.CHINA; // 或根据系统自动选择
ResourceBundle bundle = ResourceBundle.getBundle("messages", locale);
String pattern = bundle.getString("greeting");
String message = MessageFormat.format(pattern, "张三");
System.out.println(message); // 输出：你好，张三！
}
}
注意事项
文件编码 资源文件必须使用 ISO-8859-1 编码，非 ASCII 字符需转换为 Unicode 转义序列（如 \u4F60\u597D）。可通过 IDE 或 native2ascii 工具自动转换。
缺失回退机制 若未找到匹配的本地化文件，会依次回退查找： messages_zh_CN.properties → messages_zh.properties → messages.properties。
动态参数 使用 {0}, {1} 等占位符时，需确保 MessageFormat.format() 的参数数量和顺序正确。
高级用法
多模块资源 通过 ResourceBundle.Control 自定义资源加载逻辑（如从数据库读取）。日期/数字格式化 结合 NumberFormat 和 DateFormat 实现本地化显示。
程序优化建议
1. 概念定义
程序优化是指通过改进代码结构、算法选择、资源利用等方式，提高程序的执行效率、减少资源消耗或提升可维护性的过程。优化的目标通常包括：
提高运行速度降低内存占用减少CPU使用率提高代码可读性和可维护性
2. 使用场景
程序优化通常在以下情况下考虑：
程序性能不满足需求资源消耗过高（如内存泄漏）需要处理大规模数据高并发场景长期运行的服务器程序
3. 常见优化策略
3.1 算法优化
选择时间复杂度更低的算法避免不必要的嵌套循环使用缓存机制（如Memoization）
示例（斐波那契数列优化）：
// 原始递归版本（O(2^n)）
int fib(int n) {
if (n <= 1) return n;
return fib(n-1) + fib(n-2);
}
// 优化版本（O(n)）
int fibOptimized(int n) {
int a = 0, b = 1, c;
for (int i = 2; i <= n; i++) {
c = a + b;
a = b;
b = c;
}
return b;
}
3.2 数据结构选择
根据访问模式选择合适的数据结构考虑数据规模和使用场景
示例：
// 频繁查找 - 使用HashSet而不是ArrayList
Set
// vs
List
3.3 代码级优化
减少对象创建（重用对象）使用基本类型而非包装类避免在循环中创建对象
示例：
// 不推荐 - 每次循环都创建新对象
for (int i = 0; i < 10000; i++) {
String s = new String("hello"); // 创建10000个对象
}
// 推荐 - 对象复用
String s = "hello";
for (int i = 0; i < 10000; i++) {
// 使用同一个对象
}
3.4 JVM相关优化
合理设置JVM参数注意垃圾回收机制使用JIT编译优势
4. 常见误区与注意事项
4.1 过早优化
不要过早优化，应先确保功能正确遵循"先测量，再优化"原则使用性能分析工具（如VisualVM、JProfiler）定位瓶颈
4.2 可读性与优化的平衡
不要为了微小的性能提升牺牲代码可读性明显的性能瓶颈才值得优化添加必要的注释说明优化原因
4.3 测试验证
任何优化都应伴随测试确保优化不会引入新bug验证优化确实带来了性能提升
5. 优化工具推荐
JVM监控：VisualVM、JConsole性能分析：JProfiler、YourKit基准测试：JMH（Java Microbenchmark Harness）代码分析：FindBugs、PMD
6. 实际案例
字符串拼接优化：
// 不推荐 - 产生多个中间String对象
String result = "";
for (int i = 0; i < 100; i++) {
result += i; // 每次循环创建新String对象
}
// 推荐 - 使用StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
sb.append(i);
}
String result = sb.toString();