本文目录导读：
我为你整理了一个完整的Java学习专栏案例体系,从基础到高级，包含实战案例，以下是精选的Java核心案例：
基础语法案例
案例1：学生成绩管理系统（面向对象基础）
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
// 学生类
class Student {
private String id;
private String name;
private double score;
public Student(String id, String name, double score) {
this.id = id;
this.name = name;
this.score = score;
}
// getter和setter方法
public String getId() { return id; }
public void setId(String id) { this.id = id; }
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public double getScore() { return score; }
public void setScore(double score) { this.score = score; }
@Override
public String toString() {
return "学生信息 [学号=" + id + ", 姓名=" + name + ", 成绩=" + score + "]";
}
}
// 管理系统类
public class StudentManager {
private List<Student> students = new ArrayList<>();
// 添加学生
public void addStudent(Student student) {
students.add(student);
System.out.println("添加成功！");
}
// 删除学生
public void removeStudent(String id) {
boolean found = false;
for (int i = 0; i < students.size(); i++) {
if (students.get(i).getId().equals(id)) {
students.remove(i);
found = true;
System.out.println("删除成功！");
break;
}
}
if (!found) {
System.out.println("未找到该学生！");
}
}
// 修改学生信息
public void updateStudent(String id, String newName, double newScore) {
for (Student s : students) {
if (s.getId().equals(id)) {
s.setName(newName);
s.setScore(newScore);
System.out.println("修改成功！");
return;
}
}
System.out.println("未找到该学生！");
}
// 查询所有学生
public void displayAll() {
if (students.isEmpty()) {
System.out.println("暂无学生数据");
return;
}
System.out.println("=== 所有学生信息 ===");
for (Student s : students) {
System.out.println(s);
}
}
// 按成绩排序
public void sortByScore() {
students.sort((s1, s2) -> Double.compare(s2.getScore(), s1.getScore()));
System.out.println("=== 按成绩排序 ===");
displayAll();
}
// 主菜单
public static void main(String[] args) {
StudentManager manager = new StudentManager();
Scanner scanner = new Scanner(System.in);
while (true) {
System.out.println("\n=== 学生成绩管理系统 ===");
System.out.println("1. 添加学生");
System.out.println("2. 删除学生");
System.out.println("3. 修改学生");
System.out.println("4. 查询所有学生");
System.out.println("5. 按成绩排序");
System.out.println("6. 退出");
System.out.print("请选择操作：");
int choice = scanner.nextInt();
scanner.nextLine(); // 消耗换行
switch (choice) {
case 1:
System.out.print("请输入学号：");
String id = scanner.nextLine();
System.out.print("请输入姓名：");
String name = scanner.nextLine();
System.out.print("请输入成绩：");
double score = scanner.nextDouble();
manager.addStudent(new Student(id, name, score));
break;
case 2:
System.out.print("请输入要删除的学号：");
String delId = scanner.nextLine();
manager.removeStudent(delId);
break;
case 3:
System.out.print("请输入要修改的学号：");
String updId = scanner.nextLine();
System.out.print("请输入新姓名：");
String newName = scanner.nextLine();
System.out.print("请输入新成绩：");
double newScore = scanner.nextDouble();
manager.updateStudent(updId, newName, newScore);
break;
case 4:
manager.displayAll();
break;
case 5:
manager.sortByScore();
break;
case 6:
System.out.println("感谢使用本系统，再见！");
scanner.close();
return;
default:
System.out.println("无效选择，请重试！");
}
}
}
}
案例2：银行账户系统（继承与多态）
// 抽象账户类
abstract class Account {
protected String accountNo;
protected double balance;
public Account(String accountNo, double balance) {
this.accountNo = accountNo;
this.balance = balance;
}
// 抽象方法
public abstract void deposit(double amount); // 存款
public abstract void withdraw(double amount); // 取款
public abstract void calculateInterest(); // 计算利息
public double getBalance() {
return balance;
}
public String getAccountNo() {
return accountNo;
}
}
// 储蓄账户
class SavingsAccount extends Account {
private double interestRate = 0.03; // 年利率3%
public SavingsAccount(String accountNo, double balance) {
super(accountNo, balance);
}
@Override
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("储蓄账户存款 " + amount + " 元成功");
} else {
System.out.println("存款金额必须大于0");
}
}
@Override
public void withdraw(double amount) {
if (amount > 0 && amount <= balance) {
balance -= amount;
System.out.println("取款 " + amount + " 元成功");
} else {
System.out.println("取款失败，余额不足或金额无效");
}
}
@Override
public void calculateInterest() {
double interest = balance * interestRate;
System.out.println("储蓄账户利息：" + interest + " 元");
}
}
// 信用卡账户
class CreditCardAccount extends Account {
private double creditLimit;
public CreditCardAccount(String accountNo, double balance, double creditLimit) {
super(accountNo, balance);
this.creditLimit = creditLimit;
}
@Override
public void deposit(double amount) {
if (amount > 0) {
balance += amount;
System.out.println("信用卡存入 " + amount + " 元成功");
}
}
@Override
public void withdraw(double amount) {
double available = balance + creditLimit;
if (amount > 0 && amount <= available) {
balance -= amount;
System.out.println("信用卡消费 " + amount + " 元成功");
} else {
System.out.println("消费失败，超过信用额度");
}
}
@Override
public void calculateInterest() {
if (balance < 0) {
double interest = Math.abs(balance) * 0.05 * 30; // 日利率0.05%
System.out.println("信用卡需还利息：" + interest + " 元");
} else {
System.out.println("当前信用卡无透支，无需支付利息");
}
}
}
public class BankSystem {
public static void main(String[] args) {
// 使用多态
Account savings = new SavingsAccount("SA001", 5000);
Account creditCard = new CreditCardAccount("CC001", 3000, 5000);
System.out.println("=== 银行账户系统演示 ===");
// 储蓄账户操作
System.out.println("\n【储蓄账户操作】");
savings.deposit(1000);
savings.withdraw(2000);
savings.calculateInterest();
System.out.println("当前余额：" + savings.getBalance());
// 信用卡账户操作
System.out.println("\n【信用卡账户操作】");
creditCard.withdraw(3500); // 透支消费
creditCard.deposit(500); // 还款
creditCard.calculateInterest();
System.out.println("当前余额：" + creditCard.getBalance());
}
}
案例3：简易计算器（异常处理与GUI）
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
public class SimpleCalculator extends JFrame {
private JTextField display;
private double operand1 = 0;
private String operator = "";
private boolean isNewInput = true;
public SimpleCalculator() {
setTitle("简易计算器");
setSize(300, 400);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setLayout(new BorderLayout());
// 显示区域
display = new JTextField();
display.setEditable(false);
display.setFont(new Font("Arial", Font.BOLD, 24));
display.setHorizontalAlignment(JTextField.RIGHT);
add(display, BorderLayout.NORTH);
// 按钮面板
JPanel buttonPanel = new JPanel();
buttonPanel.setLayout(new GridLayout(4, 4, 5, 5));
String[] buttons = {
"7", "8", "9", "/",
"4", "5", "6", "*",
"1", "2", "3", "-",
"0", ".", "=", "+"
};
for (String btnText : buttons) {
JButton button = new JButton(btnText);
button.addActionListener(new ButtonClickListener());
buttonPanel.add(button);
}
add(buttonPanel, BorderLayout.CENTER);
}
private class ButtonClickListener implements ActionListener {
@Override
public void actionPerformed(ActionEvent e) {
String command = ((JButton) e.getSource()).getText();
try {
// 数字或小数点
if (Character.isDigit(command.charAt(0)) || command.equals(".")) {
if (isNewInput) {
display.setText(command);
isNewInput = false;
} else {
display.setText(display.getText() + command);
}
}
// 运算符
else if (command.equals("+") || command.equals("-") ||
command.equals("*") || command.equals("/")) {
if (!display.getText().isEmpty()) {
operand1 = Double.parseDouble(display.getText());
operator = command;
isNewInput = true;
}
}
// 等号
else if (command.equals("=")) {
double operand2 = Double.parseDouble(display.getText());
double result = 0;
switch (operator) {
case "+": result = operand1 + operand2; break;
case "-": result = operand1 - operand2; break;
case "*": result = operand1 * operand2; break;
case "/":
if (operand2 == 0) {
throw new ArithmeticException("除数不能为0");
}
result = operand1 / operand2; break;
default:
throw new IllegalStateException("无效的运算符");
}
display.setText(String.valueOf(result));
isNewInput = true;
}
} catch (ArithmeticException ex) {
JOptionPane.showMessageDialog(SimpleCalculator.this,
"计算错误：" + ex.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
display.setText("");
} catch (NumberFormatException ex) {
JOptionPane.showMessageDialog(SimpleCalculator.this,
"输入格式错误", "错误", JOptionPane.ERROR_MESSAGE);
}
}
}
public static void main(String[] args) {
SwingUtilities.invokeLater(() -> {
new SimpleCalculator().setVisible(true);
});
}
}
实战项目案例
案例4：多线程下载器（多线程与网络编程）
import java.io.*;
import java.net.*;
import java.util.concurrent.*;
public class MultiThreadDownloader {
private static final int THREAD_COUNT = 5;
public static void main(String[] args) {
if (args.length < 2) {
System.out.println("使用方法：java MultiThreadDownloader <URL> <保存路径>");
return;
}
String urlStr = args[0];
String savePath = args[1];
try {
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
conn.setRequestMethod("HEAD");
conn.connect();
// 获取文件大小
long fileSize = conn.getContentLengthLong();
System.out.println("文件大小：" + fileSize + " bytes");
if (fileSize <= 0) {
System.out.println("无法获取文件大小");
return;
}
// 创建随机访问文件
RandomAccessFile raf = new RandomAccessFile(savePath, "rw");
raf.setLength(fileSize);
raf.close();
// 计算每部分大小
long partSize = fileSize / THREAD_COUNT;
// 创建线程池
ExecutorService executor = Executors.newFixedThreadPool(THREAD_COUNT);
CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
// 启动下载线程
for (int i = 0; i < THREAD_COUNT; i++) {
long start = i * partSize;
long end = (i == THREAD_COUNT - 1) ? fileSize - 1 : (i + 1) * partSize - 1;
executor.execute(new DownloadTask(urlStr, savePath, start, end, latch));
}
// 等待所有线程完成
latch.await();
executor.shutdown();
System.out.println("下载完成！");
} catch (Exception e) {
e.printStackTrace();
}
}
static class DownloadTask implements Runnable {
private String urlStr;
private String savePath;
private long start;
private long end;
private CountDownLatch latch;
public DownloadTask(String urlStr, String savePath, long start, long end, CountDownLatch latch) {
this.urlStr = urlStr;
this.savePath = savePath;
this.start = start;
this.end = end;
this.latch = latch;
}
@Override
public void run() {
try {
URL url = new URL(urlStr);
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
// 设置范围请求
conn.setRequestProperty("Range", "bytes=" + start + "-" + end);
conn.connect();
try (InputStream is = conn.getInputStream();
RandomAccessFile raf = new RandomAccessFile(savePath, "rw")) {
raf.seek(start);
byte[] buffer = new byte[1024 * 1024];
int bytesRead;
long totalRead = 0;
while ((bytesRead = is.read(buffer)) != -1) {
raf.write(buffer, 0, bytesRead);
totalRead += bytesRead;
}
System.out.printf("线程 %s 下载完成：%d - %d (共 %d bytes)%n",
Thread.currentThread().getName(), start, start + totalRead, totalRead);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
latch.countDown();
}
}
}
}
案例5：简单的Web服务器（Socket编程）
import java.io.*;
import java.net.*;
import java.nio.file.*;
import java.util.concurrent.*;
public class SimpleWebServer {
private static final int PORT = 8080;
private static final String WEB_ROOT = "./www";
public static void main(String[] args) {
ExecutorService threadPool = Executors.newFixedThreadPool(10);
try (ServerSocket serverSocket = new ServerSocket(PORT)) {
System.out.println("Web服务器启动，端口：" + PORT);
while (true) {
Socket socket = serverSocket.accept();
threadPool.execute(new ClientHandler(socket));
}
} catch (IOException e) {
e.printStackTrace();
}
}
static class ClientHandler implements Runnable {
private Socket socket;
public ClientHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
// 读取请求
BufferedReader reader = new BufferedReader(
new InputStreamReader(socket.getInputStream()));
String requestLine = reader.readLine();
if (requestLine == null) return;
System.out.println("请求：" + requestLine);
// 解析请求路径
String[] parts = requestLine.split(" ");
if (parts.length < 2) return;
String filePath = parts[1];
if (filePath.equals("/")) {
filePath = "/index.html";
}
// 读取文件
Path path = Paths.get(WEB_ROOT + filePath);
File file = path.toFile();
OutputStream os = socket.getOutputStream();
if (file.exists() && file.isFile()) {
// 发送响应头
String contentType = getContentType(file.getName());
String header = "HTTP/1.1 200 OK\r\n" +
"Content-Type: " + contentType + "\r\n" +
"Content-Length: " + file.length() + "\r\n" +
"Connection: close\r\n\r\n";
os.write(header.getBytes());
// 发送文件内容
Files.copy(path, os);
} else {
// 404响应
String error = "<html><body><h1>404 - 文件未找到</h1></body></html>";
String header = "HTTP/1.1 404 Not Found\r\n" +
"Content-Type: text/html\r\n" +
"Content-Length: " + error.length() + "\r\n" +
"Connection: close\r\n\r\n";
os.write(header.getBytes());
os.write(error.getBytes());
}
os.flush();
socket.close();
} catch (Exception e) {
e.printStackTrace();
}
}
private String getContentType(String fileName) {
if (fileName.endsWith(".html")) return "text/html";
if (fileName.endsWith(".css")) return "text/css";
if (fileName.endsWith(".js")) return "application/javascript";
if (fileName.endsWith(".jpg") || fileName.endsWith(".jpeg")) return "image/jpeg";
if (fileName.endsWith(".png")) return "image/png";
return "application/octet-stream";
}
}
}
案例6：JDBC数据库操作
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
// 实体类
class User {
private int id;
private String username;
private String email;
public User(int id, String username, String email) {
this.id = id;
this.username = username;
this.email = email;
}
// getters and setters
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 getEmail() { return email; }
public void setEmail(String email) { this.email = email; }
@Override
public String toString() {
return "User [id=" + id + ", username=" + username + ", email=" + email + "]";
}
}
public class JDBCDemo {
private static final String DB_URL = "jdbc:mysql://localhost:3306/testdb";
private static final String USER = "root";
private static final String PASSWORD = "password";
public static void main(String[] args) {
try (Connection conn = DriverManager.getConnection(DB_URL, USER, PASSWORD)) {
System.out.println("数据库连接成功！");
// 创建表
createTable(conn);
// 插入数据
insertUser(conn, "张三", "zhangsan@email.com");
insertUser(conn, "李四", "lisi@email.com");
insertUser(conn, "王五", "wangwu@email.com");
// 查询数据
List<User> users = queryUsers(conn);
System.out.println("\n=== 用户列表 ===");
users.forEach(System.out::println);
// 更新数据
updateUser(conn, 1, "张三改");
// 删除数据
deleteUser(conn, 3);
// 最终查询
users = queryUsers(conn);
System.out.println("\n=== 修改后的用户列表 ===");
users.forEach(System.out::println);
} catch (SQLException e) {
e.printStackTrace();
}
}
private static void createTable(Connection conn) throws SQLException {
String sql = "CREATE TABLE IF NOT EXISTS users (" +
"id INT AUTO_INCREMENT PRIMARY KEY, " +
"username VARCHAR(50) NOT NULL, " +
"email VARCHAR(100) NOT NULL)";
try (Statement stmt = conn.createStatement()) {
stmt.executeUpdate(sql);
System.out.println("数据表创建或已存在");
}
}
private static void insertUser(Connection conn, String username, String email) throws SQLException {
String sql = "INSERT INTO users (username, email) VALUES (?, ?)";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, username);
pstmt.setString(2, email);
int affected = pstmt.executeUpdate();
System.out.println("插入用户 " + username + " 成功，影响行数：" + affected);
}
}
private static List<User> queryUsers(Connection conn) throws SQLException {
List<User> users = new ArrayList<>();
String sql = "SELECT * FROM users";
try (Statement stmt = conn.createStatement();
ResultSet rs = stmt.executeQuery(sql)) {
while (rs.next()) {
User user = new User(
rs.getInt("id"),
rs.getString("username"),
rs.getString("email")
);
users.add(user);
}
}
return users;
}
private static void updateUser(Connection conn, int id, String newUsername) throws SQLException {
String sql = "UPDATE users SET username = ? WHERE id = ?";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setString(1, newUsername);
pstmt.setInt(2, id);
int affected = pstmt.executeUpdate();
System.out.println("更新用户ID " + id + " 成功，影响行数：" + affected);
}
}
private static void deleteUser(Connection conn, int id) throws SQLException {
String sql = "DELETE FROM users WHERE id = ?";
try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
pstmt.setInt(1, id);
int affected = pstmt.executeUpdate();
System.out.println("删除用户ID " + id + " 成功，影响行数：" + affected);
}
}
}
学习建议
学习路线图
Java基础语法
↓
面向对象编程
↓
集合框架与泛型
↓
异常处理
↓
IO流与序列化
↓
多线程与并发
↓
网络编程
↓
JDBC数据库操作
↓
框架学习（Spring等）
↓
项目实战每个案例的学习重点
| 案例 | 核心知识点 | 难度等级 |
|---|---|---|
| 学生管理系统 | 类、对象、集合、循环 | |
| 银行系统 | 继承、多态、抽象类 | |
| 计算器 | 异常处理、GUI、事件 | |
| 多线程下载 | 线程池、并发编程 | |
| Web服务器 | Socket、网络编程 | |
| JDBC操作 | 数据库操作、JDBC |
实战项目推荐
-
简易聊天室
技术要点：Socket、多线程、JSON
-
图书管理系统
技术要点：JDBC、集合、MVC模式
-
在线投票系统
技术要点：Servlet、JSP、数据库
-
文件加密工具
技术要点：IO流、算法、GUI
-
股票数据可视化
技术要点：网络API调用、Swing图表
常见问题解决
// 1. 内存泄漏问题
// 解决方案：使用try-with-resources
try (Connection conn = getConnection();
PreparedStatement stmt = conn.prepareStatement(sql)) {
// 业务逻辑
} catch (SQLException e) {
e.printStackTrace();
}
// 2. 线程安全问题
// 解决方案：使用线程安全的集合
ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
CopyOnWriteArrayList<Object> list = new CopyOnWriteArrayList<>();
// 3. 性能优化
// 使用StringBuilder而非字符串拼接
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
sb.append(i);
}
这些案例涵盖了Java的核心知识点,通过实战练习，可以快速掌握Java开发技能，建议按照难度等级循序渐进地学习，并为每个案例添加自己的创新想法，加深理解。
