Java大作业——酒店管理系统（四）：客房管理

Java大作业（一）介绍了全部功能点

一、Main类——用于启动整个程序

......代码于Java大作业（二）

二、LoginWindowWindow类——用于登录

......代码于Java大作业（二）

三、FunctionSelectionWindow类——用于选择对应的功能

......代码于Java大作业（二）

四、AccountManagementWindow类——用于管理酒店工作人员账户

......代码于Java大作业（三）

   

五、RoomManagementWindow类——用于办理预定、入住、退房

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class RoomManagementWindow extends JFrame {
    private JTable roomTable;//用于展示客房信息的表格
    private DefaultTableModel tableModel;//管理表格数据
    private JButton reserveButton;//触发客房预订操作按钮
    private JButton checkInButton;//办理入住操作按钮
    private JButton checkOutButton;//执行退房操作按钮
    private List<Customer> customers;//存当前入住客户信息
    private List<Customer> customerHistory;//记过往客户入住历史

    //构造客房管理窗口
    public RoomManagementWindow() {
        setTitle("客房管理");
        setSize(1200, 800);
        setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        setLocationRelativeTo(null);

        // 初始化房间数据文件
        initializeRoomDataFile();
        customers = loadCustomerData();
        customerHistory = loadCustomerHistoryData();

        // 左侧显示酒店客房管理
        JPanel leftPanel = new JPanel();
        leftPanel.setLayout(new BoxLayout(leftPanel, BoxLayout.Y_AXIS));
        JLabel label = new JLabel("酒店客房管理", SwingConstants.CENTER);
        label.setFont(new Font("Serif", Font.BOLD, 24));
        label.setAlignmentX(Component.CENTER_ALIGNMENT);
        leftPanel.add(Box.createVerticalGlue());
        leftPanel.add(label);
        leftPanel.add(Box.createVerticalGlue());
        leftPanel.setBackground(Color.LIGHT_GRAY);

        // 右侧显示客房信息
        JPanel rightPanel = new JPanel(new BorderLayout());

        // 客房表格
        tableModel = new DefaultTableModel(new Object[]{"房间号", "房型", "金额", "状态", "入住时间", "预计离开日期", "顾客信息"}, 0);
        roomTable = new JTable(tableModel);
        roomTable.getColumnModel().getColumn(6).setCellRenderer(new ButtonRenderer());
        roomTable.getColumnModel().getColumn(6).setCellEditor(new ButtonEditor(new JCheckBox()));
        JScrollPane scrollPane = new JScrollPane(roomTable);

        // 加载房间信息
        loadRooms();

        rightPanel.add(scrollPane, BorderLayout.CENTER);

        // 预定按钮
        reserveButton = new JButton("预定");
        reserveButton.addActionListener(new ReserveActionListener());

        // 入住按钮
        checkInButton = new JButton("入住");
        checkInButton.addActionListener(new CheckInActionListener());

        // 退房按钮
        checkOutButton = new JButton("退房");
        checkOutButton.addActionListener(new CheckOutActionListener());

        // 将三个按钮放在一个面板中
        JPanel buttonPanel = new JPanel();
        buttonPanel.add(reserveButton);
        buttonPanel.add(checkInButton);
        buttonPanel.add(checkOutButton);

        rightPanel.add(buttonPanel, BorderLayout.SOUTH);

        // 分割窗格
        JSplitPane splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, leftPanel, rightPanel);
        splitPane.setDividerLocation(200);

        setContentPane(splitPane);
        setVisible(true);
    }

    //用于加载客房信息
    private void loadRooms() {
        tableModel.setRowCount(0);
        HashMap<String, Room> rooms = loadRoomData();
        for (Map.Entry<String, Room> entry : rooms.entrySet()) {
            Room room = entry.getValue();
            String checkInDate = "";
            String expectedCheckOutDate = "";
            String customerInfo = "查看";
            for (Customer customer : customers) {
                if (customer.getRoomNumber().equals(room.getNumber())) {
                    checkInDate = customer.getCheckInDate();
                    expectedCheckOutDate = customer.getExpectedCheckOutDate();
                    customerInfo = "查看";
                    break;
                }
            }
            tableModel.addRow(new Object[]{
                    room.getNumber(),
                    room.getType(),
                    room.getPrice(),
                    room.getStatus(),
                    checkInDate,
                    expectedCheckOutDate,
                    customerInfo
            });
        }
    }

    //读取指定内容
    private HashMap<String, Room> loadRoomData() {
        HashMap<String, Room> rooms = new HashMap<>();
        String filePath = "Hotel management system/src/Room";

        try (BufferedReader br = new BufferedReader(new FileReader(filePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split(",", -1);
                if (parts.length == 4) {
                    String number = parts[0].trim();
                    String type = parts[1].trim();
                    double price = Double.parseDouble(parts[2].trim());
                    String status = parts[3].trim();
                    rooms.put(number, new Room(number, type, price, status));
                } else {
                    System.err.println("Invalid line: " + line);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Error reading Room file: " + e.getMessage());
        }
        return rooms;
    }

    //读取数据，解析构建Customer对象存进列表
    private List<Customer> loadCustomerData() {
        List<Customer> customers = new ArrayList<>();
        String customerFilePath = "Hotel management system/src/Customer";

        try (BufferedReader br = new BufferedReader(new FileReader(customerFilePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split(",", -1);
                if (parts.length == 8) { // 增加预计离开日期字段
                    int id = Integer.parseInt(parts[0].trim());
                    String roomNumber = parts[1].trim();
                    String name = parts[2].trim();
                    String phone = parts[3].trim();
                    String checkInDate = parts[4].trim();
                    String expectedCheckOutDate = parts[5].trim();
                    String status = parts[6].trim();
                    String idCard = parts[7].trim();
                    customers.add(new Customer(id, roomNumber, name, phone, checkInDate, expectedCheckOutDate, status, idCard));
                } else {
                    System.err.println("Invalid line: " + line);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Error reading customers file: " + e.getMessage());
        }
        return customers;
    }

    //文件读数据，解析并完善Customer对象信息存列表
    private List<Customer> loadCustomerHistoryData() {
        List<Customer> customerHistory = new ArrayList<>();
        String customerHistoryFilePath = "Hotel management system/src/CustomerHistory";

        try (BufferedReader br = new BufferedReader(new FileReader(customerHistoryFilePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split(",", -1);
                if (parts.length == 10) { // 增加实际居住天数和消费金额字段
                    int id = Integer.parseInt(parts[0].trim());
                    String roomNumber = parts[1].trim();
                    String name = parts[2].trim();
                    String phone = parts[3].trim();
                    String checkInDate = parts[4].trim();
                    String expectedCheckOutDate = parts[5].trim();
                    String status = parts[6].trim();
                    String idCard = parts[7].trim();
                    int actualDays = Integer.parseInt(parts[8].trim());
                    double totalCost = Double.parseDouble(parts[9].trim());
                    customerHistory.add(new Customer(id, roomNumber, name, phone, checkInDate, expectedCheckOutDate, status, idCard));
                    customerHistory.get(customerHistory.size() - 1).setActualDays(actualDays);
                    customerHistory.get(customerHistory.size() - 1).setTotalCost(totalCost);
                } else {
                    System.err.println("Invalid line: " + line);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Error reading customer history file: " + e.getMessage());
        }
        return customerHistory;
    }

    //不存在或为空时初始化写入默认客房信息
    private void initializeRoomDataFile() {
        String filePath = "Hotel management system/src/Room";
        File file = new File(filePath);

        if (!file.exists() || file.length() == 0) {
            try (BufferedWriter bw = new BufferedWriter(new FileWriter(file))) {
                bw.write("501,普通单人房,100,未预定\n");
                bw.write("502,普通单人房,100,未预定\n");
                bw.write("503,普通单人房,100,未预定\n");
                bw.write("504,豪华单人房,150,未预定\n");
                bw.write("505,豪华单人房,150,未预定\n");
                bw.write("506,豪华单人房,150,未预定\n");
                bw.write("601,普通双床房,130,未预定\n");
                bw.write("602,普通双床房,130,未预定\n");
                bw.write("603,普通双床房,130,未预定\n");
                bw.write("604,豪华双床房,180,未预定\n");
                bw.write("605,豪华双床房,180,未预定\n");
                bw.write("606,豪华双床房,180,未预定\n");
            } catch (IOException e) {
                e.printStackTrace();
                System.err.println("Error initializing Room file: " + e.getMessage());
            }
        }
    }

    // 响应预订按钮点击，获取用户输入，验证选择房间状态后更新并保存相关信息，
    // 提示预订成功或部分房间问题消息。
    private class ReserveActionListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            int[] selectedRows = roomTable.getSelectedRows();
            if (selectedRows.length == 0) {
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "请选择要预定的房间！");
                return;
            }

            // 弹出预定窗口
            String checkInDate = JOptionPane.showInputDialog(RoomManagementWindow.this, "请输入入住日期（格式：YYYY-MM-DD）");
            if (checkInDate == null) {
                return; // 用户关闭或取消了对话框
            }

            String expectedCheckOutDate = JOptionPane.showInputDialog(RoomManagementWindow.this, "请输入预计离开日期（格式：YYYY-MM-DD）");
            if (expectedCheckOutDate == null) {
                return; // 用户关闭或取消了对话框
            }

            String customerName = JOptionPane.showInputDialog(RoomManagementWindow.this, "请输入顾客姓名");
            if (customerName == null) {
                return; // 用户关闭或取消了对话框
            }

            String customerPhone = JOptionPane.showInputDialog(RoomManagementWindow.this, "请输入顾客电话");
            if (customerPhone == null) {
                return; // 用户关闭或取消了对话框
            }

            boolean allReserved = true;
            HashMap<String, Room> rooms = loadRoomData();
            for (int row : selectedRows) {
                String roomNumber = (String) tableModel.getValueAt(row, 0);
                Room room = rooms.get(roomNumber);
                if (room != null && room.getStatus().equals("未预定")) {
                    room.setStatus("已预定");
                    tableModel.setValueAt("已预定", row, 3);
                    tableModel.setValueAt(checkInDate, row, 4);
                    tableModel.setValueAt(expectedCheckOutDate, row, 5);
                    saveCustomerInfo(roomNumber, customerName, customerPhone, checkInDate, expectedCheckOutDate, "已预定", "");
                } else {
                    allReserved = false;
                }
            }

            if (allReserved) {
                saveAllRoomData(rooms);
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "所有选定房间已成功预定！");
            } else {
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "部分房间已被预定或不存在！");
            }
        }
    }

    // 响应入住按钮点击，获取身份证号，依所选房间状态更新并保存相关信息，
    // 提示全部或部分房间入住成功与否消息。
    private class CheckInActionListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            int[] selectedRows = roomTable.getSelectedRows();
            if (selectedRows.length == 0) {
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "请选择要入住的房间！");
                return;
            }

            // 弹出入住窗口
            String customerID = JOptionPane.showInputDialog(RoomManagementWindow.this, "请输入顾客身份证号");
            if (customerID == null) {
                return; // 用户关闭或取消了对话框
            }

            boolean allCheckedIn = true;
            HashMap<String, Room> rooms = loadRoomData();
            for (int row : selectedRows) {
                String roomNumber = (String) tableModel.getValueAt(row, 0);
                Room room = rooms.get(roomNumber);
                if (room != null && room.getStatus().equals("已预定")) {
                    room.setStatus("已入住");
                    tableModel.setValueAt("已入住", row, 3);
                    updateCustomerInfo(roomNumber, customerID, "已入住");
                } else {
                    allCheckedIn = false;
                }
            }

            if (allCheckedIn) {
                saveAllRoomData(rooms);
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "所有选定房间已成功入住！");
            } else {
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "部分房间未预定或不存在！");
            }
        }
    }

    // 依房间号从订单数据里统计未支付餐费总和，
    // 标记对应订单为已支付，更新并保存订单数据后返回该总和。
    private double processUnpaidOrders(String roomNumber) {
        double totalUnpaid = 0.0;
        List<Order> orders = loadOrderData();

        for (Order order : orders) {
            if (order.getRoomNumber().equals(roomNumber) && order.getPaymentStatus().equals("未支付")) {
                totalUnpaid += order.getMealCost();
                // 标记订单为已支付
                order.setPaymentStatus("已支付");
            }
        }

        // 保存更新后的订单数据
        saveAllOrderData(orders);

        return totalUnpaid;
    }

    // 响应退房按钮点击，按所选房间情况处理退房，
    // 涉及费用计算、支付方式选择、信息更新等，提示退房成功与否消息。
    private class CheckOutActionListener implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e) {
            int[] selectedRows = roomTable.getSelectedRows();
            if (selectedRows.length == 0) {
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "请选择要退房的房间！");
                return;
            }

            boolean allCheckedOut = true;
            HashMap<String, Room> rooms = loadRoomData();
            for (int row : selectedRows) {
                String roomNumber = (String) tableModel.getValueAt(row, 0);
                Room room = rooms.get(roomNumber);
                Customer customer = null; // 声明 customer 变量

                if (room != null) {
                    // 查找与房间号相关的顾客
                    for (Customer c : customers) {
                        if (c.getRoomNumber().equals(roomNumber)) {
                            customer = c;
                            break;
                        }
                    }

                    if (customer == null) {
                        JOptionPane.showMessageDialog(RoomManagementWindow.this, "找不到与房间号 " + roomNumber + " 相关的顾客信息！");
                        continue;
                    }

                    if (room.getStatus().equals("已预定")) {
                        // 删除预定记录
                        deleteCustomerInfo(roomNumber);
                        room.setStatus("未预定");
                        tableModel.setValueAt("未预定", row, 3);
                        tableModel.setValueAt("", row, 4);
                        tableModel.setValueAt("", row, 5);
                    } else if (room.getStatus().equals("已入住")) {
                        // 弹出输入框让用户输入实际居住天数
                        String daysStr = JOptionPane.showInputDialog(RoomManagementWindow.this, "请输入实际居住天数");
                        if (daysStr == null) {
                            continue; // 用户关闭或取消了对话框
                        }
                        int days;
                        try {
                            days = Integer.parseInt(daysStr);
                        } catch (NumberFormatException ex) {
                            JOptionPane.showMessageDialog(RoomManagementWindow.this, "请输入有效的天数！");
                            continue;
                        }

                        // 处理未支付的订单
                        double mealCost = processUnpaidOrders(roomNumber);
                        double roomCost = room.getPrice() * days; // 计算房费
                        double totalCost = roomCost + mealCost; // 总费用 = 房费 + 餐费

                        // 选择支付方式
                        int paymentOption = JOptionPane.showOptionDialog(
                                RoomManagementWindow.this,
                                "总费用为 " + totalCost + " 元，请选择支付方式：",
                                "支付方式",
                                JOptionPane.YES_NO_OPTION,
                                JOptionPane.QUESTION_MESSAGE,
                                null,
                                new String[]{"线上支付", "现金支付"},
                                "线上支付"
                        );

                        if (paymentOption == JOptionPane.YES_OPTION) {
                            // 线上支付
                            showPaymentImage(totalCost);
                        } else if (paymentOption == JOptionPane.NO_OPTION) {
                            // 现金支付
                            JOptionPane.showMessageDialog(RoomManagementWindow.this, "请支付 " + totalCost + " 元现金。");
                        }

                        // 更新房间状态
                        room.setStatus("未预定");
                        tableModel.setValueAt("未预定", row, 3);
                        tableModel.setValueAt("", row, 4); // 清除入住日期
                        tableModel.setValueAt("", row, 5); // 清除预计离开日期

                        // 更新顾客信息
                        customer.setActualDays(days);
                        customer.setTotalCost(totalCost);

                        // 将顾客信息移到历史记录
                        moveCustomerToHistory(roomNumber);
                    } else {
                        allCheckedOut = false;
                    }
                } else {
                    allCheckedOut = false;
                }
            }

            if (allCheckedOut) {
                saveAllRoomData(rooms);
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "所有选定房间已成功退房！");
            } else {
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "部分房间未预定或不存在！");
            }
        }
    }

    //将传入的客房HashMap中各客房信息按格式写入文件，遇异常打印错误消息。
    private void saveAllRoomData(HashMap<String, Room> rooms) {
        String filePath = "Hotel management system/src/Room";

        try (BufferedWriter bw = new BufferedWriter(new FileWriter(filePath))) {
            for (Room room : rooms.values()) {
                bw.write(room.getNumber() + "," + room.getType() + "," + room.getPrice() + "," + room.getStatus() + "\n");
            }
        } catch (IOException ex) {
            ex.printStackTrace();
            System.err.println("Error saving room data: " + ex.getMessage());
        }
    }

    //创建新Customer对象加入列表，再调用方法保存所有顾客数据，用于新增顾客信息保存。
    private void saveCustomerInfo(String roomNumber, String customerName, String customerPhone, String checkInDate, String expectedCheckOutDate, String status, String idCard) {
        customers.add(new Customer(customers.size() + 1, roomNumber, customerName, customerPhone, checkInDate, expectedCheckOutDate, status, idCard));
        saveAllCustomerData();
    }

    // 按房间号查找顾客，更新其身份证号与状态信息，
    // 随后调用方法保存所有顾客数据，实现顾客信息修改保存。
    private void updateCustomerInfo(String roomNumber, String customerID, String status) {
        for (Customer customer : customers) {
            if (customer.getRoomNumber().equals(roomNumber)) {
                customer.setIdCard(customerID);
                customer.setStatus(status);
                saveAllCustomerData();
                return;
            }
        }
    }

    // 依房间号移除对应顾客信息，重新编号剩余顾客，
    // 再调用方法保存所有顾客数据，用于清理特定顾客记录。
    private void deleteCustomerInfo(String roomNumber) {
        customers.removeIf(customer -> customer.getRoomNumber().equals(roomNumber));
        renumberCustomers();
        saveAllCustomerData();
    }

    // 遍历顾客列表，按顺序为每个顾客设置新的序号（从 1 开始递增），
    // 用于更新顾客编号，保证序号连续性。
    private void renumberCustomers() {
        for (int i = 0; i < customers.size(); i++) {
            customers.get(i).setId(i + 1);
        }
    }

    //将顾客列表中各顾客信息按规定格式写入文件，遇异常则打印错误提示。
    private void saveAllCustomerData() {
        String customerFilePath = "Hotel management system/src/Customer";

        try (BufferedWriter bw = new BufferedWriter(new FileWriter(customerFilePath))) {
            for (Customer customer : customers) {
                bw.write(customer.getId() + "," + customer.getRoomNumber() + "," + customer.getName() + "," +
                        customer.getPhone() + "," + customer.getCheckInDate() + "," + customer.getExpectedCheckOutDate() + "," +
                        customer.getStatus() + "," + customer.getIdCard() + "\n");
            }
        } catch (IOException ex) {
            ex.printStackTrace();
            System.err.println("Error saving customer data: " + ex.getMessage());
        }
    }

    // 按房间号查找顾客，若找到则展示其详细信息，
    // 没找到则提示房间未预定，用于查看特定房间顾客情况。
    private void loadCustomerInfo(String roomNumber) {
        for (Customer customer : customers) {
            if (customer.getRoomNumber().equals(roomNumber)) {
                JOptionPane.showMessageDialog(RoomManagementWindow.this, "顾客信息：\n" +
                        "序号: " + customer.getId() + "\n" +
                        "房间号: " + customer.getRoomNumber() + "\n" +
                        "姓名: " + customer.getName() + "\n" +
                        "电话号码: " + customer.getPhone() + "\n" +
                        "入住日期: " + customer.getCheckInDate() + "\n" +
                        "预计离开日期: " + customer.getExpectedCheckOutDate() + "\n" +
                        "客房状态: " + customer.getStatus() + "\n" +
                        "身份证号: " + customer.getIdCard());
                return;
            }
        }

        JOptionPane.showMessageDialog(RoomManagementWindow.this, "该房间没有被预定。");
    }

    // 创建新窗口展示支付二维码图片，设置窗口属性、添加含费用提示的标签，
    // 使其可见，用于展示支付相关界面。
    private void showPaymentImage(double totalCost) {
        JFrame paymentFrame = new JFrame("支付二维码");
        paymentFrame.setSize(400, 400);
        paymentFrame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        paymentFrame.setLocationRelativeTo(this);

        ImageIcon icon = new ImageIcon("Hotel management system/src/weixinzhifuma.jpg");
        JLabel label = new JLabel(icon);
        label.setVerticalTextPosition(SwingConstants.BOTTOM);
        label.setHorizontalTextPosition(SwingConstants.CENTER);
        label.setText("总费用: " + totalCost + " 元");

        paymentFrame.add(label);
        paymentFrame.setVisible(true);
    }

    // 按房间号将顾客从当前列表移到历史列表，
    // 更新相关编号及各数据文件，清除对应房间表格顾客信息。
    private void moveCustomerToHistory(String roomNumber) {
        for (Customer customer : customers) {
            if (customer.getRoomNumber().equals(roomNumber)) {
                customerHistory.add(customer);
                customers.remove(customer);
                renumberCustomers();
                saveAllCustomerData();
                saveAllCustomerHistoryData();
                // 清除当前房间的顾客信息
                for (int i = 0; i < tableModel.getRowCount(); i++) {
                    if (tableModel.getValueAt(i, 0).equals(roomNumber)) {
                        tableModel.setValueAt("", i, 4); // 清除入住日期
                        tableModel.setValueAt("", i, 5); // 清除预计离开日期
                        tableModel.setValueAt("查看", i, 6); // 重置查看按钮
                        break;
                    }
                }
                return;
            }
        }
    }

    //把顾客历史列表信息按格式写入文件，遇异常打印错误提示信息。
    private void saveAllCustomerHistoryData() {
        String customerHistoryFilePath = "Hotel management system/src/CustomerHistory";

        try (BufferedWriter bw = new BufferedWriter(new FileWriter(customerHistoryFilePath))) {
            for (int i = 0; i < customerHistory.size(); i++) {
                Customer customer = customerHistory.get(i);
                customer.setId(i + 1); // 重新编号
                bw.write(customer.getId() + "," + customer.getRoomNumber() + "," + customer.getName() + "," +
                        customer.getPhone() + "," + customer.getCheckInDate() + "," + customer.getExpectedCheckOutDate() + "," +
                        customer.getStatus() + "," + customer.getIdCard() + "," + customer.getActualDays() + "," + customer.getTotalCost() + "\n");
            }
        } catch (IOException ex) {
            ex.printStackTrace();
            System.err.println("Error saving customer history data: " + ex.getMessage());
        }
    }

    //从文件读取数据，解析构建Order对象存进列表，遇错处理，最后返回该列表。
    private List<Order> loadOrderData() {
        List<Order> orders = new ArrayList<>();
        String orderFilePath = "Hotel management system/src/Customeryrz";

        try (BufferedReader br = new BufferedReader(new FileReader(orderFilePath))) {
            String line;
            while ((line = br.readLine()) != null) {
                String[] parts = line.split(",", -1);
                if (parts.length == 8) {
                    int id = Integer.parseInt(parts[0].trim());
                    String orderTime = parts[1].trim();
                    String roomNumber = parts[2].trim();
                    String name = parts[3].trim();
                    String dish = parts[4].trim();
                    double mealCost = Double.parseDouble(parts[5].trim());
                    String status = parts[6].trim();
                    String paymentStatus = parts[7].trim();
                    orders.add(new Order(id, orderTime, roomNumber, name, dish, mealCost, status, paymentStatus));
                } else {
                    System.err.println("Invalid line: " + line);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Error reading order data: " + e.getMessage());
        }
        return orders;
    }

    //将传入的订单列表中各订单信息按规定格式写入文件，出错则打印错误内容。
    private void saveAllOrderData(List<Order> orders) {
        String orderFilePath = "Hotel management system/src/Customeryrz";

        try (BufferedWriter bw = new BufferedWriter(new FileWriter(orderFilePath))) {
            for (Order order : orders) {
                bw.write(order.getId() + "," + order.getOrderTime() + "," + order.getRoomNumber() + "," + order.getName() + "," +
                        order.getDish() + "," + order.getMealCost() + "," + order.getStatus() + "," + order.getPaymentStatus() + "\n");
            }
        } catch (IOException ex) {
            ex.printStackTrace();
            System.err.println("Error saving order data: " + ex.getMessage());
        }
    }

    // 自定义按钮渲染类，实现TableCellRenderer接口，
    // 设置按钮透明并根据传入值设置按钮文本，用于表格渲染。
    private class ButtonRenderer extends JButton implements TableCellRenderer {
        public ButtonRenderer() {
            setOpaque(true);
        }

        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            setText(value.toString());
            return this;
        }
    }

    // 继承DefaultCellEditor，自定义表格中按钮编辑逻辑，
    // 如设置按钮样式、响应点击，点击时查看对应顾客信息等操作。
    private class ButtonEditor extends DefaultCellEditor {
        private JButton button;
        private String label;
        private boolean isPushed;

        public ButtonEditor(JCheckBox checkBox) {
            super(checkBox);
            button = new JButton();
            button.setOpaque(true);
            button.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    fireEditingStopped();
                }
            });
        }

        @Override
        public Component getTableCellEditorComponent(JTable table, Object value, boolean isSelected, int row, int column) {
            if (isSelected) {
                button.setForeground(table.getSelectionForeground());
                button.setBackground(table.getSelectionBackground());
            } else {
                button.setForeground(table.getForeground());
                button.setBackground(table.getBackground());
            }
            label = (value == null) ? "" : value.toString();
            button.setText(label);
            isPushed = true;
            return button;
        }

        @Override
        public Object getCellEditorValue() {
            if (isPushed) {
                // 弹出查看顾客信息窗口
                String roomNumber = (String) tableModel.getValueAt(roomTable.getEditingRow(), 0);
                loadCustomerInfo(roomNumber);
            }
            isPushed = false;
            return label;
        }

        @Override
        public boolean stopCellEditing() {
            isPushed = false;
            return super.stopCellEditing();
        }

        protected void fireEditingStopped() {
            super.fireEditingStopped();
        }
    }
}

class Room {
    private String number;
    private String type;
    private double price;
    private String status;

    public Room(String number, String type, double price, String status) {
        this.number = number;
        this.type = type;
        this.price = price;
        this.status = status;
    }

    public String getNumber() {
        return number;
    }

    public String getType() {
        return type;
    }

    public double getPrice() {
        return price;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }
}

class Customer {
    private int id;
    private String roomNumber;
    private String name;
    private String phone;
    private String checkInDate;
    private String expectedCheckOutDate;
    private String status;
    private String idCard;
    private int actualDays; // 新增字段
    private double totalCost; // 新增字段

    public Customer(int id, String roomNumber, String name, String phone, String checkInDate, String expectedCheckOutDate, String status, String idCard) {
        this.id = id;
        this.roomNumber = roomNumber;
        this.name = name;
        this.phone = phone;
        this.checkInDate = checkInDate;
        this.expectedCheckOutDate = expectedCheckOutDate;
        this.status = status;
        this.idCard = idCard;
        this.actualDays = 0; // 默认值
        this.totalCost = 0.0; // 默认值
    }

    // Getters and Setters for new fields
    public int getActualDays() {
        return actualDays;
    }

    public void setActualDays(int actualDays) {
        this.actualDays = actualDays;
    }

    public double getTotalCost() {
        return totalCost;
    }

    public void setTotalCost(double totalCost) {
        this.totalCost = totalCost;
    }

    // Existing getters and setters
    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getRoomNumber() {
        return roomNumber;
    }

    public String getName() {
        return name;
    }

    public String getPhone() {
        return phone;
    }

    public String getCheckInDate() {
        return checkInDate;
    }

    public String getExpectedCheckOutDate() {
        return expectedCheckOutDate;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public void setIdCard(String idCard) {
        this.idCard = idCard;
    }

    public String getIdCard() {
        return idCard;
    }
}

class Order {
    private int id;
    private String orderTime;
    private String roomNumber;
    private String name;
    private String dish;
    private double mealCost;
    private String status;
    private String paymentStatus;

    public Order(int id, String orderTime, String roomNumber, String name, String dish, double mealCost, String status, String paymentStatus) {
        this.id = id;
        this.orderTime = orderTime;
        this.roomNumber = roomNumber;
        this.name = name;
        this.dish = dish;
        this.mealCost = mealCost;
        this.status = status;
        this.paymentStatus = paymentStatus;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getOrderTime() {
        return orderTime;
    }

    public void setOrderTime(String orderTime) {
        this.orderTime = orderTime;
    }

    public String getRoomNumber() {
        return roomNumber;
    }

    public void setRoomNumber(String roomNumber) {
        this.roomNumber = roomNumber;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDish() {
        return dish;
    }

    public void setDish(String dish) {
        this.dish = dish;
    }

    public double getMealCost() {
        return mealCost;
    }

    public void setMealCost(double mealCost) {
        this.mealCost = mealCost;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getPaymentStatus() {
        return paymentStatus;
    }

    public void setPaymentStatus(String paymentStatus) {
        this.paymentStatus = paymentStatus;
    }
}