经典Java编程小实例|实战驱动·即学即用

在当今快速迭代的软件开发环境中,Java作为一门成熟、稳定且生态完善的编程语言,始终占据着企业级应用开发的主导地位。无论是金融系统、电商后台、大数据处理,还是Android移动应用开发,Java的身影无处不在。对于初学者而言,掌握一门编程语言不能仅停留在语法层面,更需要通过大量具体而微的实战案例,将抽象概念转化为可运行、可调试、可复用的代码能力。

本页面聚焦经典Java编程小实例,以“小而精”的案例切入,覆盖从基础语法到主流框架的核心知识点,每个案例均配有详细注释、运行环境说明、常见错误解析及扩展建议。我们摒弃“大而全”的理论堆砌,坚持“案例驱动、问题导向”的设计原则,让学习者在动手实践中建立完整的知识脉络,理解Java语言设计哲学与工程化思维。

每个实例均经过真实项目验证,包含以下特点:

  • · 真实场景还原:模拟开发者日常工作中常见的业务需求,如订单状态机设计、日志格式化输出、文件批量处理等;
  • · 分层讲解逻辑:从“如何实现”到“为何如此实现”,深入剖析设计权衡与性能考量;
  • · 扩展性提示:指出当前实现的局限性,并引导读者思考如何通过设计模式、框架集成等方式优化;
  • · 避坑指南:总结高频错误(如空指针、并发修改、资源泄漏),提升代码健壮性。

网站内容持续更新,涵盖Java语言基础(JDK 8~17)、面向对象核心(封装、继承、多态)、集合框架(List/Map/Set)、并发编程(ExecutorService、ForkJoin、CompletableFuture)、输入输出(NIO.2)、网络编程(Socket、HTTP Client)、数据库连接(JDBC、连接池)、以及主流框架入门(Spring Boot、MyBatis)等模块。所有示例代码可直接复制运行,建议配合本地IDE(如IntelliJ IDEA或Eclipse)同步练习。

本页面采用响应式设计,适配手机、平板、桌面端等多种设备,确保学习体验流畅无阻。所有导航均为锚点跳转,无需额外页面加载,提升访问效率。欢迎收藏、分享,并持续关注我们对经典Java编程小实例的深度拓展与实战升级。

💡 学习建议

1. 建议按模块顺序学习,但可根据需求跳转至特定章节;
2. 每个实例后附“思考题”,请务必动手实践后再查看参考答案;
3. 鼓励修改代码参数,观察输出变化,培养调试能力;
4. 遇到异常时,优先查阅JDK文档与Stack Overflow,提升自主解决问题能力。

一、Java基础语法精讲

基础是编程的根基,看似简单,却藏着许多易被忽略的细节。以下精选6个高频基础实例,覆盖变量、运算符、流程控制、方法重载、数组操作及字符串处理,助你夯实根基。

⚡ 实例1:三元运算符的嵌套陷阱

许多初学者误以为三元运算符(? :)仅适用于简单判断,实则其可嵌套使用,但过度嵌套将严重降低可读性。以下案例对比正确与错误写法:

int score = 85; String level = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : "D";

上述代码虽能运行,但嵌套三层后维护困难。推荐改用if-else或策略模式(见后续章节)。更安全的写法:

String level; if (score >= 90) level = "A"; else if (score >= 80) level = "B"; else if (score >= 70) level = "C"; else level = "D";

【思考题】请将上述逻辑改写为方法,接收score参数并返回等级字符串,同时增加参数校验(如负数或超100分时抛出异常)。

⚙️ 实例2:静态方法与实例方法的调用差异

静态方法属于类本身,可通过类名直接调用;实例方法需通过对象调用。常见错误是混淆两者:

public class MathUtil { public static int add(int a, int b) { return a + b; } public int multiply(int a, int b) { return a * b; } } // 正确调用 int sum = MathUtil.add(3, 5); // 静态方法 MathUtil util = new MathUtil(); int product = util.multiply(4, 6); // 实例方法

注意:静态方法中不能直接访问实例成员(变量或方法),因为其无this引用。以下错误写法将导致编译失败:

public static void wrong() { int x = 10; System.out.println(x); // 正确:x是局部变量 System.out.println(this.x); // 编译错误:静态方法中无this }

【扩展】静态方法常用于工具类(如Math、Arrays),实例方法用于描述对象行为(如String的substring())。

⚡ 实例3:数组越界异常的防御性编程

数组访问前务必检查索引范围。以下代码演示如何安全遍历二维数组:

int[][] matrix = {{1,2,3}, {4,5}}; 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
注意:第二行仅2个元素,若用固定长度j<3会导致ArrayIndexOutOfBoundsException!

⚡ 实例4:字符串拼接的性能优化

循环中拼接字符串时,避免使用“+”(每次创建新String对象),应改用StringBuilder:

String result = ""; for (int i = 0; i < 1000; i++) { result += i + ","; // 低效:创建1000个临时对象 }

优化后:

StringBuilder sb = new StringBuilder(); for (int i = 0; i < 1000; i++) { sb.append(i).append(","); } String result = sb.toString(); // 高效:仅1个对象

【原理】String为不可变类,“+”操作会创建新对象;StringBuilder可变,内部字符数组动态扩容。

⚡ 实例5:局部变量作用域与生命周期

局部变量在方法内定义,仅在当前代码块有效。以下代码演示作用域嵌套:

public static void scopeDemo() { int x = 10; // 方法作用域 if (x > 0) { int y = 20; // if代码块作用域 System.out.println(x + y); // 输出30 } // System.out.println(y); // 编译错误:y超出作用域 }

【注意】同名变量在内层作用域会遮蔽外层变量,但需谨慎使用以防混淆。

⚡ 实例6:方法重载与类型自动提升

方法重载需满足:方法名相同、参数列表不同(类型/数量/顺序)。以下案例展示自动类型提升的优先级:

public static void print(int a) { System.out.println("int: " + a); } public static void print(long a) { System.out.println("long: " + a); } public static void print(double a) { System.out.println("double: " + a); } print(10); // 输出 int: 10 print(10L); // 输出 long: 10 print(10.0); // 输出 double: 10.0

【关键点】当无精确匹配时,按byte→short→int→long→float→double顺序自动提升类型。例如print(10.0f)将匹配float版本;若缺失则报错。

二、面向对象核心实践

面向对象(OOP)是Java的基石,通过封装、继承、多态实现高内聚低耦合。以下实例深入解析三大特性,并对比传统过程式编程的局限性。

⚡ 实例1:封装与信息隐藏(银行卡系统)

封装将数据(属性)与操作(方法)绑定,隐藏内部细节。以下模拟银行卡账户:

public class BankAccount { private String accountNo; private double balance; public BankAccount(String accountNo, double initBalance) { this.accountNo = accountNo; this.balance = initBalance; } public void deposit(double amount) { if (amount > 0) balance += amount; } public boolean withdraw(double amount) { if (amount > 0 && amount <= balance) { balance -= amount; return true; } return false; } public double getBalance() { return balance; } public String getAccountNo() { return accountNo; } }

【优势】外部无法直接修改balance,必须通过deposit/withdraw方法,确保数据一致性。若外部误操作(如balance = -100),封装可阻止此类错误。

⚙️ 实例2:继承中的构造器调用顺序

子类构造器默认调用父类无参构造器(super())。若父类无无参构造器,需显式调用:

class Animal { String name; Animal(String name) { this.name = name; } } class Dog extends Animal { Dog(String name) { super(name); // 必须显式调用 System.out.println("Dog created: " + name); } }

【执行顺序】父类构造器 → 子类构造器剩余代码。若缺少super(name),编译报错:Cannot resolve constructor Animal()。

⚡ 实例3:多态与动态绑定(支付系统)

多态允许父类引用指向子类对象,运行时根据实际类型调用方法:

abstract class Payment { abstract void pay(double amount); } class WeChatPay extends Payment { void pay(double amount) { System.out.println("微信支付:" + amount + "元"); } } class AliPay extends Payment { void pay(double amount) { System.out.println("支付宝支付:" + amount + "元"); } } // 调用 Payment p1 = new WeChatPay(); Payment p2 = new AliPay(); p1.pay(100); // 微信支付:100.0元 p2.pay(200); // 支付宝支付:200.0元

【关键点】pay()方法在编译期绑定到Payment类型,运行时动态绑定到实际对象(WeChatPay/AliPay),实现“同一操作,不同行为”。

⚡ 实例4:抽象类 vs 接口

抽象类用于“is-a”关系,可有构造器和成员变量;接口用于“can-do”能力,JDK8后可有默认方法:

interface Flyable { void fly(); // 默认public abstract default void land() { System.out.println("着陆中..."); } // 新增默认方法 } abstract class Bird { String name; Bird(String name) { this.name = name; } abstract void eat(); } class Sparrow extends Bird implements Flyable { Sparrow() { super("麻雀"); } void eat() { System.out.println(name + "吃虫子"); } public void fly() { System.out.println(name + "在飞行"); } }

【设计原则】优先用接口(更灵活),需共享代码时用抽象类(如JDK的AbstractList)。

⚡ 实例5:组合优于继承(打印机系统)

继承易导致“脆弱基类”问题。以下用组合实现更灵活的打印机:

class InkCartridge { void refill() { System.out.println("加墨"); } } class PaperTray { void load(int sheets) { System.out.println("装纸:" + sheets + "张"); } } class Printer { private InkCartridge ink; private PaperTray tray; Printer() { this.ink = new InkCartridge(); this.tray = new PaperTray(); } void print(String content) { ink.refill(); tray.load(10); System.out.println("打印内容:" + content); } }

【优势】可独立替换墨盒/纸盒,无需修改Printer类;继承则需重写整个子类。

三、集合框架实战详解

Java集合框架是开发核心模块,合理选择集合类型直接影响性能与代码可读性。以下实例对比List、Set、Map的典型用法与陷阱。

⚡ 实例1:ArrayList vs LinkedList

两者均为List实现,但底层结构不同:

List list1 = new ArrayList<>(); List list2 = new LinkedList<>(); list1.add("A"); list1.add(1, "B"); // ArrayList:索引1后插入,需移动后续元素 list2.add("A"); list2.add(1, "B"); // LinkedList:仅修改指针,O(1)时间

【结论】频繁随机访问用ArrayList;频繁插入/删除用LinkedList(尤其中间位置)。注意:LinkedList的get(i)是O(n)!

⚙️ 实例2:HashSet的去重原理

HashSet基于HashMap实现,元素唯一性依赖hashCode()与equals():

class Person { String name; Person(String name) { this.name = name; } // 未重写hashCode/equals时,new Person("Tom")两次视为不同对象 } Set set = new HashSet<>(); set.add(new Person("Tom")); set.add(new Person("Tom")); System.out.println(set.size()); // 输出2(错误!)

【正确做法】重写hashCode()与equals():

public int hashCode() { return name.hashCode(); } public boolean equals(Object o) { return o instanceof Person && name.equals(((Person)o).name); }

【原则】若两个对象equals()返回true,则hashCode()必须相同!

⚡ 实例3:HashMap的线程安全替代方案

HashMap非线程安全,高并发下可能死循环。安全方案:

// 方案1:Collections.synchronizedMap Map syncMap = Collections.synchronizedMap(new HashMap<>()); // 方案2:ConcurrentHashMap(推荐) ConcurrentHashMap concurrentMap = new ConcurrentHashMap<>(); concurrentMap.put("A", 1); concurrentMap.computeIfAbsent("B", k -> 2); // 原子操作

【性能对比】ConcurrentHashMap分段锁机制,高并发下性能远超同步Map。

⚡ 实例4:遍历集合时删除元素的正确姿势

直接for循环删除会导致ConcurrentModificationException:

List list = new ArrayList<>(Arrays.asList("A", "B", "C")); // 错误写法:for (String s : list) if (s.equals("B")) list.remove(s); // 异常! // 正确写法1:使用Iterator Iterator it = list.iterator(); while (it.hasNext()) { if (it.next().equals("B")) it.remove(); } // 正确写法2:Java 8 removeIf list.removeIf(s -> s.equals("B"));

【原理】增强for循环本质使用Iterator,但直接调用list.remove()绕过迭代器,导致modCount变化。

⚡ 实例5:TreeMap的排序特性

TreeMap基于红黑树,自动按键排序(自然顺序或自定义比较器):

Map map = new TreeMap<>(); map.put("C", 3); map.put("A", 1); map.put("B", 2); for (String key : map.keySet()) { System.out.println(key + "=" + map.get(key)); } // 输出:A=1 B=2 C=3

【注意】键必须可比较(实现Comparable),或提供Comparator。否则抛ClassCastException。

⚡ 实例6:CopyOnWriteArrayList的适用场景

读多写少的并发场景(如监听器列表),写操作时复制新数组:

CopyOnWriteArrayList cowList = new CopyOnWriteArrayList<>(); cowList.add("A"); cowList.add("B"); // 遍历时允许并发修改 for (String s : cowList) { if (s.equals("A")) cowList.add("C"); // 不抛异常! }

【代价】写操作成本高(复制开销),内存占用翻倍。慎用于大数据量场景。

四、多线程编程核心案例

并发编程是Java的难点,掌握线程创建、同步机制及现代并发工具是进阶必经之路。以下实例直击高频问题。

⚡ 实例1:线程创建的三种方式

对比Thread、Runnable、Callable的使用场景:

// 方式1:继承Thread(不推荐,单继承限制) class MyThread extends Thread { public void run() { System.out.println("Thread run"); } } new MyThread().start(); // 方式2:实现Runnable(推荐,解耦) class MyTask implements Runnable { public void run() { System.out.println("Runnable run"); } } new Thread(new MyTask()).start(); // 方式3:实现Callable + Future(可返回结果) class MyCallable implements Callable { public Integer call() { return 42; } } FutureTask future = new FutureTask<>(new MyCallable()); new Thread(future).start(); System.out.println(future.get()); // 阻塞等待结果

【最佳实践】优先使用Runnable/Callable,避免继承Thread的局限性。

⚙️ 实例2:synchronized的三种用法

确保多线程共享数据的安全性:

class Counter { private int count = 0; // 1. 同步方法(锁this) public synchronized void increment() { count++; } // 2. 同步代码块(锁任意对象) public void safeIncrement() { synchronized(this) { count++; } } // 3. 静态方法同步(锁Class对象) public static synchronized void staticInc() { } }

【关键点】同步方法锁this;静态同步方法锁Class;同步块可指定任意锁对象,粒度更细。

⚡ 实例3:线程通信wait/notify机制

生产者-消费者模型的经典实现:

class Buffer { private int data; private boolean hasData = false; public synchronized void put(int value) { while (hasData) wait(); // 等待消费 data = value; hasData = true; notify(); // 唤醒消费者 } public synchronized int take() { while (!hasData) wait(); // 等待生产 hasData = false; notify(); // 唤醒生产者 return data; } }

【注意】必须在同步块中调用wait/notify;用while而非if防止虚假唤醒。

⚡ 实例4:ExecutorService线程池管理

避免频繁创建销毁线程,提高资源利用率:

ExecutorService pool = Executors.newFixedThreadPool(3); for (int i = 0; i < 5; i++) { pool.submit(() -> { System.out.println(Thread.currentThread().getName() + "执行任务"); }); } pool.shutdown(); // 优雅关闭

【线程池类型】

  • newFixedThreadPool:固定大小,适合稳定负载
  • newCachedThreadPool:按需创建,适合突发任务
  • newScheduledThreadPool:定时任务
  • newSingleThreadExecutor:单线程顺序执行

⚡ 实例5:volatile关键字的内存可见性

确保变量修改对其他线程立即可见,但不保证原子性:

class Worker implements Runnable { private volatile boolean running = true; public void run() { while (running) { // 执行任务 } } public void stop() { running = false; } }

【对比】若无volatile,主线程修改running=false后,工作线程可能因缓存未刷新而继续循环。

⚡ 实例6:CompletableFuture异步编排

Java 8引入的异步编程模型,简化多任务协作:

CompletableFuture.supplyAsync(() -> { return "Hello"; }).thenApply(s -> s + " World") .thenAccept(System.out::println); // 输出:Hello World

【优势】链式调用替代回调地狱;支持异常处理(exceptionally);可组合多个异步任务(allOf/anyOf)。

五、输入输出流深度解析

文件操作是Java的常用场景,掌握传统IO与NIO.2的差异,可写出高效可靠的文件处理代码。

⚡ 实例1:文件复制的四种方式

对比字节流、字符流、缓冲流及NIO.2的性能差异:

// 方式1:字节流逐字节复制(极慢) FileInputStream in = new FileInputStream("src.txt"); FileOutputStream out = new FileOutputStream("dst.txt"); int b; while ((b = in.read()) != -1) out.write(b); // 方式2:字节流缓冲复制(推荐) BufferedInputStream bin = new BufferedInputStream(new FileInputStream("src.txt")); BufferedOutputStream bout = new BufferedOutputStream(new FileOutputStream("dst.txt")); byte[] buffer = new byte[8192]; int len; while ((len = bin.read(buffer)) != -1) bout.write(buffer, 0, len); // 方式3:NIO.2 Files.copy(最简洁) Files.copy(Paths.get("src.txt"), Paths.get("dst.txt")); // 方式4:NIO.2 Channel复制(高效大文件) FileChannel src = FileChannel.open(Paths.get("src.txt"), StandardOpenOption.READ); FileChannel dst = FileChannel.open(Paths.get("dst.txt"), StandardOpenOption.WRITE, StandardOpenOption.CREATE); src.transferTo(0, src.size(), dst);

【结论】小文件用Files.copy;大文件用Channel.transferTo();避免逐字节读写!

⚙️ 实例2:对象序列化与反序列化

实现对象持久化,需实现Serializable接口:

class User implements Serializable { private static final long serialVersionUID = 1L; private String name; private transient int age; // transient字段不序列化 // 构造器、getter/setter... } // 序列化 ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("user.ser")); oos.writeObject(new User("Tom", 25)); // 反序列化 ObjectInputStream ois = new ObjectInputStream(new FileInputStream("user.ser")); User user = (User) ois.readObject(); // age为0

【注意】serialVersionUID不匹配时抛InvalidClassException;transient字段不参与序列化。

⚡ 实例3:文件监控WatchService

实时监听目录变化(新增/修改/删除):

WatchService watcher = FileSystems.getDefault().newWatchService(); Path dir = Paths.get("logs"); dir.register(watcher, StandardWatchEventKinds.ENTRY_CREATE, StandardWatchEventKinds.ENTRY_MODIFY, StandardWatchEventKinds.ENTRY_DELETE); // 轮询事件 while (true) { WatchKey key = watcher.take(); for (WatchEvent event : key.pollEvents()) { System.out.println(event.kind() + ": " + event.context()); } key.reset(); }

【应用场景】日志监控、配置热加载、自动同步工具。

⚡ 实例4:RandomAccessFile随机访问

支持文件任意位置读写,类似C语言fseek:

RandomAccessFile raf = new RandomAccessFile("data.bin", "rw"); raf.seek(100); // 移动到第100字节 raf.write("Hello".getBytes()); raf.seek(200); int value = raf.readInt(); // 读取4字节整数

【注意】seek()位置必须有效;write()覆盖原内容,非追加。

⚡ 实例5:NIO.2 Path与Files工具类

现代文件操作API,语义清晰且跨平台:

// 读取文件内容为字符串 String content = Files.readString(Paths.get("config.txt")); // 写入多行文本 List lines = Arrays.asList("A", "B", "C"); Files.write(Paths.get("output.txt"), lines); // 遍历目录(递归) Files.walk(Paths.get("src")).forEach(path -> { if (Files.isRegularFile(path)) { System.out.println(path.getFileName()); } });

【优势】支持符号链接、属性视图(如BasicFileAttributes);自动处理路径分隔符。

六、网络编程实战指南

网络编程是Java的强项,从Socket到HTTP Client,掌握核心API可构建可靠网络应用。

⚡ 实例1:TCP Socket通信(单线程)

服务器与客户端的最简通信模型:

// 服务器端 ServerSocket server = new ServerSocket(8080); Socket client = server.accept(); // 阻塞等待连接 InputStream in = client.getInputStream(); OutputStream out = client.getOutputStream(); out.write("Hello Client".getBytes()); client.close(); server.close(); // 客户端 Socket socket = new Socket("localhost", 8080); InputStream in = socket.getInputStream(); OutputStream out = socket.getOutputStream(); out.write("Hello Server".getBytes()); byte[] buffer = new byte[1024]; int len = in.read(buffer); System.out.println(new String(buffer, 0, len)); socket.close();

【注意】需处理IOException;生产环境需多线程处理多连接。

⚙️ 实例2:UDP无连接通信

无需建立连接,适合实时性要求高的场景:

// 发送端 DatagramSocket socket = new DatagramSocket(); byte[] data = "Hello UDP".getBytes(); DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("localhost"), 9000); socket.send(packet); // 接收端 DatagramSocket server = new DatagramSocket(9000); byte[] buffer = new byte[1024]; DatagramPacket packet = new DatagramPacket(buffer, buffer.length); server.receive(packet); // 阻塞等待 System.out.println(new String(buffer, 0, packet.getLength()));

【特点】无连接、不可靠、低延迟;常用于视频流、DNS查询。

⚡ 实例3:Java 11 HttpClient异步请求

现代HTTP客户端,支持同步/异步、WebSocket:

HttpClient client = HttpClient.newHttpClient(); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://api.xservx.com/data")) .GET() .build(); // 同步请求 HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); System.out.println(response.body()); // 异步请求 client.sendAsync(request, HttpResponse.BodyHandlers.ofString()) .thenApply(HttpResponse::body) .thenAccept(System.out::println) .join();

【优势】替代过时的HttpURLConnection;支持HTTP/2、异步回调。

⚡ 实例4:URL解析与资源下载

解析URL并下载文件:

URL url = new URL("https://www.xservx.com/logo.png"); HttpURLConnection conn = (HttpURLConnection) url.openConnection(); conn.setRequestMethod("GET"); conn.setConnectTimeout(5000); conn.setReadTimeout(5000); try (InputStream in = conn.getInputStream(); OutputStream out = new FileOutputStream("logo.png")) { byte[] buffer = new byte[4096]; int len; while ((len = in.read(buffer)) != -1) { out.write(buffer, 0, len); } }

【注意】需检查HTTP状态码(conn.getResponseCode());避免硬编码URL。

⚡ 实例5:代理服务器配置

通过代理访问网络(如公司内网):

Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy.company.com", 8080)); HttpClient client = HttpClient.newBuilder() .proxy(proxy) .build(); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create("https://external.com/api")) .GET() .build(); client.send(request, HttpResponse.BodyHandlers.ofString());

【扩展】可设置认证头(Proxy-Authorization)。

七、数据库连接实战

JDBC是Java操作数据库的标准API,掌握连接、事务、预处理等核心概念是开发基础。

⚡ 实例1:JDBC基本操作(增删改查)

使用DriverManager获取连接,执行SQL:

String url = "jdbc:mysql://localhost:3306/test"; String user = "root"; String password = "123456"; try (Connection conn = DriverManager.getConnection(url, user, password)) { // 插入 String sql = "INSERT INTO users (name, email) VALUES (?, ?)"; try (PreparedStatement stmt = conn.prepareStatement(sql)) { stmt.setString(1, "Tom"); stmt.setString(2, "tom@example.com"); stmt.executeUpdate(); } // 查询 try (Statement stmt = conn.createStatement(); ResultSet rs = stmt.executeQuery("SELECT * FROM users")) { while (rs.next()) { System.out.println(rs.getInt("id") + " " + rs.getString("name")); } } }

【注意】使用PreparedStatement防SQL注入;try-with-resources自动关闭资源。

⚙️ 实例2:事务处理(转账案例)

确保转账操作的原子性:

try (Connection conn = DriverManager.getConnection(url, user, password)) { conn.setAutoCommit(false); // 关闭自动提交 // 扣款 PreparedStatement debit = conn.prepareStatement("UPDATE accounts SET balance = balance - ? WHERE id = ?"); debit.setDouble(1, 100); debit.setInt(2, 1); debit.executeUpdate(); // 加款(模拟异常) PreparedStatement credit = conn.prepareStatement("UPDATE accounts SET balance = balance + ? WHERE id = ?"); credit.setDouble(1, 100); credit.setInt(2, 2); credit.executeUpdate(); conn.commit(); // 提交事务 } catch (Exception e) { conn.rollback(); // 回滚 e.printStackTrace(); }

【关键点】必须关闭自动提交;异常时调用rollback();提交后自动提交状态恢复。

⚡ 实例3:连接池(HikariCP)

避免频繁创建连接,提升性能:

HikariConfig config = new HikariConfig(); config.setJdbcUrl("jdbc:mysql://localhost:3306/test"); config.setUsername("root"); config.setPassword("123456"); config.setMaximumPoolSize(10); HikariDataSource dataSource = new HikariDataSource(config); try (Connection conn = dataSource.getConnection()) { // 使用连接执行SQL... } // 自动归还连接到池

【优势】连接复用;自动管理连接生命周期;比手动连接池更高效。

⚡ 实例4:元数据获取表结构

动态获取数据库信息:

DatabaseMetaData meta = conn.getMetaData(); try (ResultSet tables = meta.getTables(null, null, null, new String[]{"TABLE"})) { while (tables.next()) { System.out.println("表名: " + tables.getString("TABLE_NAME")); } } // 获取表字段信息 try (ResultSet columns = meta.getColumns(null, null, "users", null)) { while (columns.next()) { System.out.println(columns.getString("COLUMN_NAME") + " (" + columns.getString("TYPE_NAME") + ")"); } }

【应用场景】ORM框架基础;数据库文档生成。

⚡ 实例5:批量操作优化

减少网络往返,提升批量插入效率:

String sql = "INSERT INTO logs (message, created) VALUES (?, ?)"; try (PreparedStatement stmt = conn.prepareStatement(sql)) { for (int i = 0; i < 1000; i++) { stmt.setString(1, "Log " + i); stmt.setTimestamp(2, new Timestamp(System.currentTimeMillis())); stmt.addBatch(); // 添加到批处理 if (i % 100 == 0) { stmt.executeBatch(); // 每100条提交一次 stmt.clearBatch(); } } stmt.executeBatch(); // 处理剩余 }

【注意】MySQL需开启rewriteBatchedStatements=true参数才生效。

八、Spring框架入门实例

Spring是Java企业级开发的事实标准,掌握IoC、AOP、事务管理是进阶必备技能。

⚡ 实例1:Spring IoC容器基础(XML配置)

创建Bean并注入依赖:

// Spring配置文件 beans.xml // Java调用 ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml"); UserService service = context.getBean("userService", UserService.class);

【核心概念】IoC:对象创建权交给Spring容器;DI:通过setter/构造器注入依赖。

⚙️ 实例2:注解驱动开发(@Component/@Autowired)

简化XML配置,支持自动扫描:

@Component public class UserService { @Autowired private UserRepository userRepository; } // 启动时扫描组件 @ComponentScan(basePackages = "com.example") public class AppConfig {} // 获取Bean AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

【优势】配置精简;类型安全;IDE支持更好。

⚡ 实例3:AOP实现日志记录

在不修改业务代码前提下,统一添加日志:

@Aspect @Component public class LogAspect { @Around("execution(* com.example.service.*.*(..))") public Object logExecution(ProceedingJoinPoint joinPoint) throws Throwable { System.out.println("进入方法: " + joinPoint.getSignature()); Object result = joinPoint.proceed(); System.out.println("退出方法: " + result); return result; } }

【应用场景】权限校验、性能监控、事务管理。

⚡ 实例4:声明式事务(@Transactional)

简化事务管理,替代手动控制:

@Service public class AccountService { @Autowired private AccountDao accountDao; @Transactional public void transfer(String from, String to, double amount) { accountDao.debit(from, amount); accountDao.credit(to, amount); // 异常时自动回滚 } }

【注意】必须通过代理调用(方法非private);默认只回滚RuntimeException。

⚡ 实例5:Spring Boot快速启动

零配置构建Web应用:

@SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } } @RestController public class HelloController { @GetMapping("/hello") public String hello() { return "Hello Spring Boot!"; } }

【优势】内嵌Tomcat;自动配置;生产就绪功能(健康检查、指标)。

九、开发工具与调试技巧

高效开发离不开工具支持,掌握调试、测试、构建工具可显著提升效率。

⚡ 实例1:IntelliJ IDEA调试技巧

核心调试功能:

  • · 断点:点击行号旁设断点(F9继续);
  • · 条件断点:右键断点→Condition,如id == 10;
  • · 表达式求值:调试时Alt+F8输入表达式;
  • · 日志点:无暂停直接输出变量值;
  • · 远程调试:启动JVM加参数 -agentlib:jdwp=transport=dt_socket,server=y,suspend=n

⚙️ 实例2:JUnit单元测试实践

编写可重复验证的测试用例:

@Test void testDeposit() { BankAccount account = new BankAccount("ACC001", 100); account.deposit(50); assertEquals(150, account.getBalance(), 0.01); } @Test(expected = IllegalArgumentException.class) void testNegativeDeposit() { BankAccount account = new BankAccount("ACC001", 100); account.deposit(-10); // 应抛出异常 }

【最佳实践】测试用例独立;使用@Before/@After准备/清理数据。

⚡ 实例3:Maven依赖管理

项目依赖与构建配置:

<dependencies> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.3.20</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.29</version> </dependency> </dependencies>

【核心命令】mvn clean compile test package install

⚡ 实例4:Git分支管理策略

团队协作开发流程:

  • · main:生产稳定分支;
  • · develop:集成开发分支;
  • · feature/*:新功能分支;
  • · hotfix/*:紧急修复分支。

合并流程:feature → develop → main,避免直接提交main。

⚡ 实例5:日志框架配置(SLF4J + Logback)

统一日志接口与实现:

// 代码中使用 private static final Logger logger = LoggerFactory.getLogger(MyClass.class); logger.info("用户登录: {}", userId); // logback.xml配置 %d{HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n

【关键点】使用{}占位符避免字符串拼接;生产环境日志级别设为WARN。

十、高频问题解答

整理开发者最常搜索的10个问题,提供深度解析与解决方案。

⚡ 1. Java中String为什么是不可变的?

设计原因:

  • · 线程安全:多线程共享无需同步;
  • · 缓存哈希值:String.hashCode()可缓存;
  • · 字符串池优化:避免重复创建相同字符串;
  • · 安全性:URL、密码等参数不可被篡改。

【影响】字符串拼接性能低;使用StringBuilder优化;intern()可复用字符串池对象。

⚙️ 2. 为什么重写equals()必须重写hashCode()?

hashCode()约定:相同对象必须返回相同哈希值。若仅重写equals(),可能导致:

Map map = new HashMap<>(); Person p1 = new Person("Tom"); Person p2 = new Person("Tom"); map.put(p1, "value1"); System.out.println(map.get(p2)); // 可能为null!

【原理】HashMap通过hashCode()定位桶,equals()比较键。若hashCode不同,即使equals()为true也无法找到。

⚡ 3. Java内存模型(JMM)核心概念?

三大特性:

  • · 原子性:基本类型读写原子(long/double除外);
  • · 可见性:volatile、synchronized、Lock保证修改对其他线程可见;
  • · 有序性:volatile禁止指令重排;synchronized保证代码块原子性。

【happens-before原则】程序顺序规则、volatile变量规则、锁规则等。

⚡ 4. 如何避免NPE(空指针)?

防御性编程技巧:

  • · 使用Optional包装可能为null的值;
  • · 字符串比较时将常量放前面:"Tom".equals(name);
  • · 避免返回null,改用Optional.empty()或空集合;
  • · 使用Objects.requireNonNull()检查参数;
  • · 初始化集合时用Collections.emptyList()等。

⚡ 5. Java 8的新特性有哪些实用价值?

核心亮点:

  • · Lambda表达式:简化匿名内部类;
  • · Stream API:函数式处理集合;
  • · Optional:避免NPE;
  • · 默认方法:接口可有实现;
  • · 日期API:java.time包替代Date/Calendar。

⚙️ 6. 为什么ArrayList的默认容量是11?

实际为10(JDK 8后)!常见误区:早期版本是11,JDK 8改为10。扩容公式为oldCapacity + (oldCapacity >> 1),即1.5倍。

⚡ 7. Java 17 LTS有哪些重要更新?

关键特性:

  • · 密封类(Sealed Classes):限制继承/实现;
  • · 模式匹配(instanceof):简化类型检查;
  • · 记录类(Records):自动生成equals/hashCode;
  • · 文本块(Text Blocks):多行字符串;
  • · ZGC:低延迟垃圾回收器(实验性)。

⚡ 8. 如何选择集合类?

决策树:

  • · 是否需要排序? → 是:TreeMap/TreeSet;否:HashMap/HashSet;
  • · 是否需要线程安全? → 是:ConcurrentHashMap/Collections.synchronizedMap;
  • · 是否需要保持插入顺序? → 是:LinkedHashMap/LinkedHashSet;
  • · 是否需要快速随机访问? → 是:ArrayList;否:LinkedList。

⚡ 9. Java程序启动慢如何优化?

优化策略:

  • · 使用GraalVM编译为原生镜像;
  • · 启用类数据共享(CDS);
  • · 减少依赖库体积;
  • · 避免过度初始化(懒加载);
  • · 使用JVM参数优化(-XX:+UseG1GC)。

⚙️ 10. 为什么Java没有指针?

设计哲学:Java通过引用(Reference)替代指针,隐藏内存地址细节,提升安全性与跨平台性。但底层仍存在指针概念(如sun.misc.Unsafe),仅限内部使用。