Java 核心编程案例：从基础语法到高级实践精讲233

作为一名专业的程序员，熟练掌握Java这门语言是职业生涯中不可或缺的一部分。Java以其“一次编写，到处运行”的特性、强大的生态系统和在企业级应用、大数据、Android开发等领域的广泛应用，成为了全球最受欢迎的编程语言之一。本文将通过一系列精选的Java案例代码，从基础的面向对象概念到更高级的并发编程和现代特性，带你深入理解Java的核心机制和最佳实践，帮助你构建稳健、高效的应用程序。

一、Java面向对象基础案例：构建一个简易的交通工具系统

面向对象编程（OOP）是Java的核心。它通过封装、继承和多态三大特性，让代码更易于理解、维护和扩展。我们从一个简单的交通工具系统开始。

1.1 封装：定义一个基础的交通工具类

封装是将数据（属性）和操作数据的方法（行为）捆绑在一起，并对外部隐藏内部实现细节。使用访问修饰符（如`private`）可以实现封装。
public class Vehicle {
private String brand; // 品牌
private String model; // 型号
private int year; // 年份
public Vehicle(String brand, String model, int year) {
= brand;
= model;
= year;
}
// Getter方法：提供对私有属性的受控访问
public String getBrand() {
return brand;
}
public String getModel() {
return model;
}
public int getYear() {
return year;
}
// Setter方法：提供对私有属性的受控修改
public void setBrand(String brand) {
= brand;
}
public void setModel(String model) {
= model;
}
public void setYear(int year) {
if (year > 1900 && year 150) {
throw new InvalidUserDataException("用户年龄无效: " + ());
}
("用户数据校验通过: " + ());
}
public static void main(String[] args) {
String testFilePath = "";
// 创建一个测试文件
try {
((testFilePath), ("100", "hello", "200", "300"));
} catch (IOException e) {
("创建测试文件失败: " + ());
}
("--- 使用传统方式读取文件 ---");
readFileLegacy(testFilePath);
("--- 使用现代方式读取文件 ---");
readFileModern(testFilePath);
("--- 演示自定义异常 ---");
try {
validateUserData(new User("001", "Alice", 30));
validateUserData(new User("002", "", 25)); // 抛出异常
} catch (InvalidUserDataException e) {
("用户数据校验失败: " + ());
}
}
}

四、Java多线程与并发案例：模拟异步任务执行

在现代应用程序中，多线程是实现并发和提高响应能力的关键。Java提供了强大的并发API。
import .*;
// 任务类，实现Runnable接口
class MyRunnableTask implements Runnable {
private String taskName;
private int duration; // 模拟任务执行时长
public MyRunnableTask(String taskName, int duration) {
= taskName;
= duration;
}
@Override
public void run() {
(().getName() + " - " + taskName + " 开始执行...");
try {
(duration); // 模拟耗时操作
} catch (InterruptedException e) {
().interrupt(); // 重新设置中断状态
(().getName() + " - " + taskName + " 被中断。");
}
(().getName() + " - " + taskName + " 执行完毕。");
}
}
// 任务类，实现Callable接口，可以返回结果
class MyCallableTask implements Callable<String> {
private String taskName;
private int duration;
public MyCallableTask(String taskName, int duration) {
= taskName;
= duration;
}
@Override
public String call() throws Exception {
(().getName() + " - " + taskName + " (Callable) 开始执行...");
(duration);
(().getName() + " - " + taskName + " (Callable) 执行完毕。");
return "结果: " + taskName + " 在 " + ().getName() + " 上完成。";
}
}
public class ConcurrencyDemo {
public static void main(String[] args) throws InterruptedException, ExecutionException {
("--- 传统Thread方式 ---");
Thread thread1 = new Thread(new MyRunnableTask("任务 A", 2), "Thread-A");
Thread thread2 = new Thread(new MyRunnableTask("任务 B", 3), "Thread-B");
();
();
// 主线程可能先于子线程结束，因为子线程是异步执行的
("主线程继续执行，等待子线程完成...");
(); // 等待thread1执行完毕
(); // 等待thread2执行完毕
("所有传统Thread任务完成。");

("--- 使用ExecutorService管理线程池 ---");
// 创建一个固定大小的线程池，最多同时运行3个线程
ExecutorService executorService = (3);
// 提交Runnable任务
(new MyRunnableTask("任务 C", 1));
(new MyRunnableTask("任务 D", 4));
(new MyRunnableTask("任务 E", 2));
(new MyRunnableTask("任务 F", 3)); // 任务F会在有空闲线程时被执行
// 提交Callable任务，可以获取执行结果
Future<String> future1 = (new MyCallableTask("计算任务 1", 2));
Future<String> future2 = (new MyCallableTask("计算任务 2", 1));
// 获取Callable任务的结果 (get方法会阻塞直到任务完成)
try {
("获取计算任务 1 结果: " + ());
("获取计算任务 2 结果: " + ());
} catch (InterruptedException | ExecutionException e) {
("获取任务结果时发生错误: " + ());
}
// 关闭线程池，不再接受新任务，并等待已提交任务完成
();
// awaitTermination() 可以等待所有任务在指定时间内完成
if (!(10, )) {
("线程池中的部分任务未能按时完成。");
(); // 强制关闭所有正在执行的任务
}
("ExecutorService 任务全部完成。");
("--- 线程安全问题示例 (AtomicInteger) ---");
// 错误的计数器，非线程安全
class Counter {
private int count = 0;
public void increment() { count++; }
public int getCount() { return count; }
}
// 线程安全的计数器
class SafeCounter {
private atomicCount = new (0);
public void increment() { (); }
public int getCount() { return (); }
}
ExecutorService counterExecutor = (10);
Counter unsafeCounter = new Counter();
SafeCounter safeCounter = new SafeCounter();
for (int i = 0; i < 1000; i++) {
(unsafeCounter::increment);
(safeCounter::increment);
}
();
(1, );
// 由于线程调度不确定性，非线程安全的计数器结果可能小于1000
("非线程安全计数器结果: " + ());
("线程安全计数器结果: " + ()); // 结果总是1000
}
}

五、Java 8+ 新特性案例：Lambda表达式与Stream API

Java 8引入了Lambda表达式和Stream API，极大地简化了集合操作，使代码更简洁、可读性更强。
import ;
import ;
import ;
import ;
public class Java8FeaturesDemo {
public static void main(String[] args) {
List<User> users = (
new User("001", "Alice", 30),
new User("002", "Bob", 25),
new User("003", "Charlie", 35),
new User("004", "David", 25),
new User("005", "Eve", 40)
);
("--- Lambda 表达式 ---");
// 传统方式遍历列表
("传统遍历:");
for (User user : users) {
(());
}
// Lambda表达式 forEach
("Lambda forEach:");
(user -> (()));
// Lambda表达式用于排序 (Comparator)
("按年龄排序 (升序):");
((u1, u2) -> ((), ()));
(user -> (() + " (" + () + ")"));
("--- Stream API ---");
// 1. 过滤 (filter): 查找年龄大于30的用户
("年龄大于30的用户:");
()
.filter(user -> () > 30)
.forEach(::println);
// 2. 映射 (map): 获取所有用户的姓名，并收集到新列表
("所有用户的姓名:");
List<String> names = ()
.map(User::getName) // 方法引用
.collect(());
(names);
// 3. 统计 (count, average, sum, max, min)
long count = ().count();
("用户总数: " + count);
double averageAge = ()
.mapToInt(User::getAge) // 映射为IntStream
.average()
.orElse(0.0);
("平均年龄: " + ("%.2f", averageAge));
// 4. 归约 (reduce): 计算所有用户年龄之和
int totalAge = ()
.mapToInt(User::getAge)
.sum();
("总年龄: " + totalAge);
// 5. 分组 (groupingBy): 按年龄分组用户
("按年龄分组用户:");
Map<Integer, List<User>> usersByAge = ()
.collect((User::getAge));
((age, userList) -> {
("年龄 " + age + ":");
(user -> (" " + ()));
});
// 6. 链式操作：筛选出年龄大于等于25且小于等于35的用户，按姓名倒序，收集姓名
("年龄在25到35之间，按姓名倒序的用户:");
List<String> filteredAndSortedNames = ()
.filter(user -> () >= 25 && () <= 35)
.sorted((u1, u2) -> ().compareTo(())) // 倒序
.map(User::getName)
.collect(());
(filteredAndSortedNames);
}
}

六、总结与展望

本文通过多个Java案例代码，涵盖了从面向对象编程的核心概念（封装、继承、多态、接口）到常用集合框架（List、Set、Map），再到健壮性编程的异常处理机制，以及现代并发编程和Java 8+新特性（Lambda、Stream API）的应用。这些案例旨在提供实用的代码片段和深入的解释，帮助你理解Java语言的强大功能和最佳实践。

掌握这些基础和进阶知识，是成为一名优秀Java开发者的基石。然而，Java的魅力远不止于此，它的生态系统庞大而活跃，包括JDBC数据库连接、Servlet/JSP Web开发、Spring/Spring Boot框架、ORM工具（如Hibernate）、消息队列（Kafka/RabbitMQ）、微服务架构等。鼓励你在理解这些核心案例的基础上，继续探索更广阔的Java世界，通过持续学习和实践，不断提升你的编程技能。

Java在不断发展，每个新版本都会带来新的特性和改进。保持对最新技术的关注，积极尝试和应用它们，将使你的代码更加现代化、高效和可维护。祝你在Java编程的道路上越走越远，创造出更多优秀的软件作品！

2025-11-23

上一篇：深入理解Java代码作用域：从基础到高级实践

下一篇：Java中RSA加解密与数字签名：深入解析Byte数组的关键作用