当前位置： 首页 > news >正文

《Java 程序设计》核心知识点梳理与深入探究

news 2025/8/2 5:57:14

引言

        Java 作为一门广泛应用的编程语言，从桌面应用到企业级系统，从移动开发到大数据处理，都能看到它的身影。本文将梳理 Java 程序设计的核心知识点，总结各章节的重难点，并深入探究几个关键话题，帮助读者构建完整的 Java 知识体系并提升实践能力。

一、Java 编程核心知识点梳理

知识体系总览

各章节重难点总结

1. Java 语言概述
  • 重点：JDK、JRE 和 JVM 的关系，Java 平台独立性原理
  • 难点：Java 字节码执行机制
2. Java 语言基础
  • 重点：基本数据类型，变量与常量，运算符
  • 难点：数据类型转换规则，运算符优先级
3. 选择与循环
  • 重点：if-else 语句，switch 语句，三种循环结构
  • 难点：循环嵌套，break 与 continue 的区别和使用场景
4. 类和对象
  • 重点：类的定义，对象的创建与使用，方法设计
  • 难点：构造方法，this 关键字，静态成员，值传递与引用传递
5. 数组
  • 重点：数组的定义与初始化，数组的基本操作
  • 难点：二维数组的内存结构，Arrays 工具类的使用
6. 字符串
  • 重点：String 类常用方法，StringBuilder 与 StringBuffer
  • 难点：String 的不可变性，字符串池机制
7. 继承与多态
  • 重点：继承的实现，方法重写，super 关键字
  • 难点：多态的实现原理，动态绑定机制
8. Java 常用核心类
  • 重点：Object 类，包装类，日期时间类
  • 难点：equals () 与 hashCode () 的关系，自动装箱与拆箱
9. 内部类、枚举和注解
  • 重点：匿名内部类，枚举类型的使用
  • 难点：注解的定义与应用
10. 接口与 Lambda 表达式
  • 重点：接口的定义与实现，函数式接口
  • 难点：Lambda 表达式语法与应用场景
11. 泛型与集合
  • 重点：集合框架体系，List、Set、Map 的使用
  • 难点：泛型擦除机制，Stream API 的操作
12. 异常处理
  • 重点：try-catch-finally 结构，异常类型
  • 难点：自定义异常，异常处理最佳实践
13. 输入输出
  • 重点：字节流与字符流，文件操作
  • 难点：对象序列化，NIO 的使用
14-15. JavaFX 相关
  • 重点：JavaFX 程序结构，常用控件与布局
  • 难点：事件处理机制
16. JDBC 数据库编程
  • 重点：数据库连接步骤，SQL 语句执行
  • 难点：PreparedStatement 的使用，连接池
17. 并发编程基础
  • 重点：线程创建方式，线程同步机制
  • 难点：线程安全问题，锁机制
18. Java 网络编程
  • 重点：TCP/UDP 通信，URL 操作
  • 难点：Socket 编程，多客户端通信

二、深入探究的话题

话题 1：多线程并发编程与线程安全

        多线程是 Java 编程中的重要特性，也是面试中的高频考点。合理使用多线程可以充分利用 CPU 资源，提高程序效率，但也会带来线程安全问题。

原理分析

        线程安全问题主要源于多个线程对共享资源的并发访问。当多个线程同时读写共享数据时，如果没有适当的同步机制，就可能导致数据不一致的问题。

Java 提供了多种线程同步机制：

  • synchronized 关键字（同步方法和同步块）
  • Lock 接口及其实现类（如 ReentrantLock）
  • 原子类（如 AtomicInteger）
  • 并发集合（如 ConcurrentHashMap）

代码实现：线程安全的计数器

下面实现一个线程安全的计数器，并对比不同同步机制的性能：

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/*** 线程安全计数器示例* 对比三种同步机制：synchronized方法、ReentrantLock、AtomicInteger*/
public class ThreadSafeCounter {public static void main(String[] args) throws InterruptedException {// 测试不同的计数器实现testCounter(new SynchronizedCounter(), "Synchronized方法");testCounter(new LockCounter(), "ReentrantLock");testCounter(new AtomicCounter(), "AtomicInteger");}/*** 测试计数器性能*/private static void testCounter(Counter counter, String name) throws InterruptedException {int threadCount = 10;int incrementsPerThread = 100000;Thread[] threads = new Thread[threadCount];// 创建并启动线程long startTime = System.currentTimeMillis();for (int i = 0; i < threadCount; i++) {threads[i] = new Thread(() -> {for (int j = 0; j < incrementsPerThread; j++) {counter.increment();}});threads[i].start();}// 等待所有线程完成for (Thread thread : threads) {thread.join();}long endTime = System.currentTimeMillis();// 输出结果System.out.printf("%s: 最终值 = %d, 耗时 = %d ms%n", name, counter.get(), endTime - startTime);}/*** 计数器接口*/interface Counter {void increment();long get();}/*** 使用synchronized方法实现的计数器*/static class SynchronizedCounter implements Counter {private long count = 0;@Overridepublic synchronized void increment() {count++;}@Overridepublic synchronized long get() {return count;}}/*** 使用ReentrantLock实现的计数器*/static class LockCounter implements Counter {private long count = 0;private final Lock lock = new ReentrantLock();@Overridepublic void increment() {lock.lock();try {count++;} finally {lock.unlock();}}@Overridepublic long get() {lock.lock();try {return count;} finally {lock.unlock();}}}/*** 使用AtomicInteger实现的计数器*/static class AtomicCounter implements Counter {private final AtomicInteger count = new AtomicInteger(0);@Overridepublic void increment() {count.incrementAndGet();}@Overridepublic long get() {return count.get();}}
}
实践结果

运行上述程序，典型输出结果如下：

Synchronized方法: 最终值 = 1000000, 耗时 = 23 ms
ReentrantLock: 最终值 = 1000000, 耗时 = 18 ms
AtomicInteger: 最终值 = 1000000, 耗时 = 5 ms

可以看到：

  1. 三种同步机制都保证了计数器的线程安全，最终值都是预期的 1000000
  2. 性能上：AtomicInteger > ReentrantLock > synchronized 方法
  3. AtomicInteger 性能最好，因为它使用了 CAS（Compare-And-Swap）无锁机制，减少了线程切换开销

话题 2：集合框架与 Stream API 高级应用

        集合框架是 Java 开发中最常用的 API 之一，而 Stream API 则为集合操作提供了更简洁、高效的方式。

原理分析

Java 集合框架主要分为三大类：

  • List：有序可重复的集合
  • Set：无序不可重复的集合
  • Map：键值对映射的集合

        Stream API 是 Java 8 引入的新特性，它允许我们以声明式方式处理集合数据。Stream 操作可以分为中间操作（返回 Stream）和终端操作（返回具体结果）。

代码实现：电商订单数据分析

下面通过一个电商订单数据分析的例子，展示集合框架和 Stream API 的综合应用：

import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.Month;
import java.util.*;
import java.util.stream.Collectors;/*** 电商订单数据分析示例* 展示集合框架与Stream API的综合应用*/
public class OrderAnalysis {// 订单类static class Order {private final String orderId;private final LocalDate orderDate;private final String customerId;private final List<OrderItem> items;private final String status;public Order(String orderId, LocalDate orderDate, String customerId, List<OrderItem> items, String status) {this.orderId = orderId;this.orderDate = orderDate;this.customerId = customerId;this.items = items;this.status = status;}// 获取订单总金额public BigDecimal getTotalAmount() {return items.stream().map(item -> item.getPrice().multiply(BigDecimal.valueOf(item.getQuantity()))).reduce(BigDecimal.ZERO, BigDecimal::add);}// getter方法public String getOrderId() { return orderId; }public LocalDate getOrderDate() { return orderDate; }public String getCustomerId() { return customerId; }public List<OrderItem> getItems() { return items; }public String getStatus() { return status; }}// 订单项类static class OrderItem {private final String productId;private final String productName;private final int quantity;private final BigDecimal price;public OrderItem(String productId, String productName, int quantity, BigDecimal price) {this.productId = productId;this.productName = productName;this.quantity = quantity;this.price = price;}// getter方法public String getProductId() { return productId; }public String getProductName() { return productName; }public int getQuantity() { return quantity; }public BigDecimal getPrice() { return price; }}public static void main(String[] args) {// 创建测试数据List<Order> orders = createTestOrders();System.out.println("===== 1. 计算2023年第二季度总销售额 =====");BigDecimal q2Total = orders.stream().filter(order -> "完成".equals(order.getStatus())).filter(order -> {LocalDate date = order.getOrderDate();return date.getYear() == 2023 && date.getMonth().getValue() >= 4 && date.getMonth().getValue() <= 6;}).map(Order::getTotalAmount).reduce(BigDecimal.ZERO, BigDecimal::add);System.out.println("2023年第二季度总销售额: " + q2Total + " 元");System.out.println("\n===== 2. 找出销量最高的前3名产品 =====");Map<String, Integer> productSales = orders.stream().filter(order -> "完成".equals(order.getStatus())).flatMap(order -> order.getItems().stream()).collect(Collectors.groupingBy(OrderItem::getProductName,Collectors.summingInt(OrderItem::getQuantity)));productSales.entrySet().stream().sorted(Map.Entry.<String, Integer>comparingByValue().reversed()).limit(3).forEach(entry -> System.out.println(entry.getKey() + ": " + entry.getValue() + " 件"));System.out.println("\n===== 3. 按月份统计订单数量和平均金额 =====");Map<Month, List<Order>> ordersByMonth = orders.stream().filter(order -> "完成".equals(order.getStatus())).collect(Collectors.groupingBy(order -> order.getOrderDate().getMonth()));ordersByMonth.entrySet().stream().sorted(Map.Entry.comparingByKey()).forEach(entry -> {Month month = entry.getKey();List<Order> monthOrders = entry.getValue();long count = monthOrders.size();BigDecimal avgAmount = monthOrders.stream().map(Order::getTotalAmount).reduce(BigDecimal.ZERO, BigDecimal::add).divide(BigDecimal.valueOf(count), 2, BigDecimal.ROUND_HALF_UP);System.out.printf("%s: 订单数=%d, 平均金额=%.2f 元%n", month, count, avgAmount);});System.out.println("\n===== 4. 找出每个客户的最高金额订单 =====");Map<String, Order> maxOrderPerCustomer = orders.stream().filter(order -> "完成".equals(order.getStatus())).collect(Collectors.toMap(Order::getCustomerId,order -> order,(existing, replacement) -> existing.getTotalAmount().compareTo(replacement.getTotalAmount()) > 0 ? existing : replacement));maxOrderPerCustomer.forEach((customerId, order) -> System.out.printf("客户 %s: 最高金额订单 %s, 金额 %.2f 元%n",customerId, order.getOrderId(), order.getTotalAmount()));}// 创建测试订单数据private static List<Order> createTestOrders() {List<Order> orders = new ArrayList<>();// 客户1的订单orders.add(new Order("O001", LocalDate.of(2023, 4, 15), "C001",Arrays.asList(new OrderItem("P001", "笔记本电脑", 1, new BigDecimal("5999.00")),new OrderItem("P002", "鼠标", 1, new BigDecimal("99.00"))), "完成"));orders.add(new Order("O002", LocalDate.of(2023, 5, 20), "C001",Arrays.asList(new OrderItem("P003", "键盘", 1, new BigDecimal("199.00"))), "完成"));// 客户2的订单orders.add(new Order("O003", LocalDate.of(2023, 4, 25), "C002",Arrays.asList(new OrderItem("P004", "手机", 1, new BigDecimal("3999.00")),new OrderItem("P005", "手机壳", 2, new BigDecimal("29.00"))), "完成"));orders.add(new Order("O004", LocalDate.of(2023, 6, 10), "C002",Arrays.asList(new OrderItem("P006", "耳机", 1, new BigDecimal("799.00"))), "完成"));// 客户3的订单orders.add(new Order("O005", LocalDate.of(2023, 5, 5), "C003",Arrays.asList(new OrderItem("P001", "笔记本电脑", 1, new BigDecimal("5999.00")),new OrderItem("P007", "背包", 1, new BigDecimal("159.00"))), "完成"));// 取消的订单orders.add(new Order("O006", LocalDate.of(2023, 6, 15), "C001",Arrays.asList(new OrderItem("P008", "显示器", 1, new BigDecimal("1499.00"))), "取消"));// 7月份的订单（不在第二季度）orders.add(new Order("O007", LocalDate.of(2023, 7, 1), "C003",Arrays.asList(new OrderItem("P009", "打印机", 1, new BigDecimal("899.00"))), "完成"));return orders;}
}
实践结果

运行上述程序，输出结果如下：

这个例子展示了如何使用 Stream API 进行复杂的数据聚合和分析：

  1. 使用 filter () 筛选符合条件的订单
  2. 使用 map () 进行数据转换
  3. 使用 collect () 进行数据收集和分组
  4. 使用 reduce () 进行数据聚合
  5. 结合 Collectors 工具类进行复杂的分组统计

话题 3：JDBC 数据库编程与连接池

        数据库操作是大多数 Java 应用的核心功能，JDBC 是 Java 访问数据库的标准 API。连接池则是提高数据库操作性能的重要手段。

原理分析

JDBC 操作数据库的基本步骤：

  1. 加载数据库驱动
  2. 建立数据库连接
  3. 创建 Statement/PreparedStatement 对象
  4. 执行 SQL 语句
  5. 处理结果集
  6. 关闭资源

数据库连接池的工作原理：

  • 预先创建一定数量的数据库连接
  • 当应用需要访问数据库时，从连接池获取连接
  • 使用完毕后，将连接归还给连接池，而不是关闭
  • 连接池负责管理连接的创建、复用和销毁

代码实现：基于连接池的用户管理系统

下面实现一个基于连接池的用户管理系统，使用 HikariCP 作为连接池：

首先，需要添加 HikariCP 依赖（Maven）：

<dependency><groupId>com.zaxxer</groupId><artifactId>HikariCP</artifactId><version>4.0.3</version>
</dependency>
<dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><version>8.0.28</version>
</dependency>

Java 代码：

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;import java.sql.*;
import java.util.ArrayList;
import java.util.List;/*** 基于连接池的用户管理系统* 使用HikariCP作为连接池*/
public class UserManager {// 数据库连接池private static HikariDataSource dataSource;// 静态初始化块，配置连接池static {// 配置连接池HikariConfig config = new HikariConfig();config.setJdbcUrl("jdbc:mysql://localhost:3306/testdb?useSSL=false&serverTimezone=UTC");config.setUsername("root");config.setPassword("password"); // 替换为你的数据库密码// 连接池配置config.setMaximumPoolSize(10); // 最大连接数config.setMinimumIdle(5);      // 最小空闲连接数config.setIdleTimeout(300000); // 空闲连接超时时间(ms)config.setMaxLifetime(1800000); // 连接最大生存期(ms)config.setConnectionTimeout(30000); // 获取连接超时时间(ms)// 初始化数据源dataSource = new HikariDataSource(config);// 初始化数据库表initializeTable();}/*** 初始化用户表*/private static void initializeTable() {String createTableSQL = "CREATE TABLE IF NOT EXISTS users (" +"id INT AUTO_INCREMENT PRIMARY KEY," +"username VARCHAR(50) NOT NULL UNIQUE," +"password VARCHAR(50) NOT NULL," +"email VARCHAR(100) NOT NULL," +"age INT," +"reg_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP)";try (Connection conn = dataSource.getConnection();Statement stmt = conn.createStatement()) {stmt.execute(createTableSQL);System.out.println("用户表初始化成功");} catch (SQLException e) {System.err.println("初始化用户表失败: " + e.getMessage());}}/*** 用户实体类*/public static class User {private int id;private String username;private String password;private String email;private int age;// 构造方法和getter/setterpublic User(String username, String password, String email, int age) {this.username = username;this.password = password;this.email = email;this.age = age;}public User(int id, String username, String password, String email, int age) {this.id = id;this.username = username;this.password = password;this.email = email;this.age = age;}// getter和setter方法public int getId() { return id; }public void setId(int id) { this.id = id; }public String getUsername() { return username; }public void setUsername(String username) { this.username = username; }public String getPassword() { return password; }public void setPassword(String password) { this.password = password; }public String getEmail() { return email; }public void setEmail(String email) { this.email = email; }public int getAge() { return age; }public void setAge(int age) { this.age = age; }@Overridepublic String toString() {return "User{id=" + id + ", username='" + username + "', email='" + email + "', age=" + age + "}";}}/*** 添加用户*/public boolean addUser(User user) {String sql = "INSERT INTO users (username, password, email, age) VALUES (?, ?, ?, ?)";try (Connection conn = dataSource.getConnection();PreparedStatement pstmt = conn.prepareStatement(sql)) {pstmt.setString(1, user.getUsername());pstmt.setString(2, user.getPassword());pstmt.setString(3, user.getEmail());pstmt.setInt(4, user.getAge());int rows = pstmt.executeUpdate();return rows > 0;} catch (SQLException e) {System.err.println("添加用户失败: " + e.getMessage());return false;}}/*** 根据ID查询用户*/public User getUserById(int id) {String sql = "SELECT * FROM users WHERE id = ?";try (Connection conn = dataSource.getConnection();PreparedStatement pstmt = conn.prepareStatement(sql)) {pstmt.setInt(1, id);ResultSet rs = pstmt.executeQuery();if (rs.next()) {return new User(rs.getInt("id"),rs.getString("username"),rs.getString("password"),rs.getString("email"),rs.getInt("age"));}} catch (SQLException e) {System.err.println("查询用户失败: " + e.getMessage());}return null;}/*** 查询所有用户*/public List<User> getAllUsers() {List<User> users = new ArrayList<>();String sql = "SELECT * FROM users";try (Connection conn = dataSource.getConnection();PreparedStatement pstmt = conn.prepareStatement(sql);ResultSet rs = pstmt.executeQuery()) {while (rs.next()) {users.add(new User(rs.getInt("id"),rs.getString("username"),rs.getString("password"),rs.getString("email"),rs.getInt("age")));}} catch (SQLException e) {System.err.println("查询所有用户失败: " + e.getMessage());}return users;}/*** 更新用户信息*/public boolean updateUser(User user) {String sql = "UPDATE users SET username=?, password=?, email=?, age=? WHERE id=?";try (Connection conn = dataSource.getConnection();PreparedStatement pstmt = conn.prepareStatement(sql)) {pstmt.setString(1, user.getUsername());pstmt.setString(2, user.getPassword());pstmt.setString(3, user.getEmail());pstmt.setInt(4, user.getAge());pstmt.setInt(5, user.getId());int rows = pstmt.executeUpdate();return rows > 0;} catch (SQLException e) {System.err.println("更新用户失败: " + e.getMessage());return false;}}/*** 删除用户*/public boolean deleteUser(int id) {String sql = "DELETE FROM users WHERE id = ?";try (Connection conn = dataSource.getConnection();PreparedStatement pstmt = conn.prepareStatement(sql)) {pstmt.setInt(1, id);int rows = pstmt.executeUpdate();return rows > 0;} catch (SQLException e) {System.err.println("删除用户失败: " + e.getMessage());return false;}}/*** 关闭连接池*/public static void closeDataSource() {if (dataSource != null) {dataSource.close();System.out.println("连接池已关闭");}}/*** 测试方法*/public static void main(String[] args) {UserManager manager = new UserManager();// 测试添加用户System.out.println("\n===== 添加用户 =====");User user1 = new User("张三", "123456", "zhangsan@example.com", 25);User user2 = new User("李四", "654321", "lisi@example.com", 30);System.out.println("添加用户1: " + (manager.addUser(user1) ? "成功" : "失败"));System.out.println("添加用户2: " + (manager.addUser(user2) ? "成功" : "失败"));// 测试查询所有用户System.out.println("\n===== 查询所有用户 =====");List<User> users = manager.getAllUsers();users.forEach(System.out::println);// 测试查询单个用户if (!users.isEmpty()) {int userId = users.get(0).getId();System.out.println("\n===== 查询用户 ID=" + userId + " =====");User user = manager.getUserById(userId);System.out.println(user);// 测试更新用户System.out.println("\n===== 更新用户 =====");if (user != null) {user.setAge(26);user.setEmail("new_zhangsan@example.com");System.out.println("更新用户: " + (manager.updateUser(user) ? "成功" : "失败"));System.out.println("更新后的用户: " + manager.getUserById(userId));}// 测试删除用户System.out.println("\n===== 删除用户 =====");System.out.println("删除用户 ID=" + userId + ": " + (manager.deleteUser(userId) ? "成功" : "失败"));System.out.println("删除后查询用户: " + manager.getUserById(userId));}// 关闭连接池closeDataSource();}
}
实践结果

运行上述程序前，请确保：

  1. 已安装 MySQL 数据库
  2. 已创建名为 testdb 的数据库
  3. 已修改数据库连接参数（用户名、密码）以匹配你的环境

程序运行输出结果如下：

用户表初始化成功===== 添加用户 =====
添加用户1: 成功
添加用户2: 成功===== 查询所有用户 =====
User{id=1, username='张三', email='zhangsan@example.com', age=25}
User{id=2, username='李四', email='lisi@example.com', age=30}===== 查询用户 ID=1 =====
User{id=1, username='张三', email='zhangsan@example.com', age=25}===== 更新用户 =====
更新用户: 成功
更新后的用户: User{id=1, username='张三', email='new_zhangsan@example.com', age=26}===== 删除用户 =====
删除用户 ID=1: 成功
删除后查询用户: null
连接池已关闭

这个例子展示了：

  1. 如何配置和使用 HikariCP 连接池
  2. JDBC 的 CRUD 基本操作
  3. PreparedStatement 的使用，防止 SQL 注入
  4. try-with-resources 语法自动关闭资源

        使用连接池可以显著提高数据库操作性能，特别是在高并发场景下，避免了频繁创建和关闭数据库连接的开销。

三、总结与展望

        本文梳理了 Java 程序设计的核心知识点，总结了各章节的重难点，并深入探究了多线程并发编程、集合框架与 Stream API、JDBC 数据库编程与连接池三个关键话题。

        Java 作为一门不断发展的编程语言，新的特性和 API 不断涌现，如模块化系统、Records、Sealed Classes 等。要想真正掌握 Java 编程，除了理解核心概念和原理外，更重要的是通过大量实践来积累经验。

建议读者在学习过程中：

  1. 多动手编写代码，理解每个知识点的实际应用场景
  2. 阅读 JDK 源码，深入理解底层实现原理
  3. 学习设计模式，提高代码质量和可维护性
  4. 关注 Java 社区动态，了解最新发展趋势

        希望本文能帮助读者构建完整的 Java 知识体系，为进一步深入学习和实践打下坚实基础。

http://www.lryc.cn/news/606748.html

相关文章：

  • 深入理解C语言指针：从回调函数到数组指针笔试题全解析（下）
  • Canny边缘检测算法-个人记录
  • 【世纪龙科技】3D交互深度赋能-汽车整车维护仿真教学软件
  • 汽车供应链PPAP自动化审核指南：如何用AI实现规则精准匹配与文件智能校验
  • 【世纪龙科技】汽车整车维护仿真教学软件-智构整车维护实训
  • 目标检测检出率，误检率，ap，map等评估python代码
  • 防火墙安全策略实验一
  • 分类预测 | Matlab实现CPO-PNN冠豪猪算法优化概率神经网络多特征分类预测
  • Redis学习-----Redis的基本数据类型
  • 数学与应用数学的区别是什么
  • CSS font-weight:500不生效
  • Mysql join语句
  • 智慧能源管理平台的多层协同控制架构研究
  • ansible 在EE 容器镜像中运行
  • 在SQL SERVER 中,用SSMS 实现存储过程的每日自动调用
  • 守护数字核心：主机安全的重要性与全方位防护指南
  • Java 根据多个 MM-dd 日期计算总时长（包含当日和次日）
  • 新手小白如何快速检测IP 的好坏？
  • OSPF笔记整理
  • JavaWeb（苍穹外卖）--学习笔记16（定时任务工具Spring Task,Cron表达式）
  • 电子电气架构 --- 加速48V技术应用的平衡之道
  • SpringMVC的高级特性
  • mongodb中的哈希索引详解
  • Redis深度剖析：从基础到实战（下）
  • Unity3D数学第五篇：几何计算与常用算法（实用算法篇）
  • 【BFS】P7555 [USACO21OPEN] Maze Tac Toe S|普及+
  • 【C#学习Day16笔记】XML文件、 事件Event 、Json数据
  • JavaWeb--Student2025项目：条件查询、批量删除、新增、修改
  • 2025新征程杯全国54校园足球锦标赛在北京世园公园隆重开幕
  • Java 开发中的 DTO 模式：从理论到实践的完整指南