Java专栏案例

wen java案例 2026-07-31 254

本文目录导读：

Java专栏案例

基础语法案例
实战项目案例
学习建议

我为你整理了一个完整的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开发技能，建议按照难度等级循序渐进地学习，并为每个案例添加自己的创新想法，加深理解。

本文地址： https://www.bmjup.com/post/35041.html