Java GUI：如何使用布局管理器重构我的界面？

Hey there! Let's tackle your Swing menu refactor and go over the issues in your current code step by step. First, let's list out the bad practices and bugs in your existing implementation, then we'll rewrite it using proper layout managers.

Bad Practices & Issues in Your Current Code #

• Using null layout: This is the biggest culprit here. Null layout makes your UI non-resizable, platform-dependent, and a nightmare to maintain. Components won't adjust when the window is resized, and they might render incorrectly on different OSes or screen resolutions.
• Hardcoding component sizes/locations: Lines like p.setSize(600,50) or runMenuButt.setLocation(20, 90) tie your UI to fixed pixel values. If you ever need to change the window size or add new components, you'll have to manually adjust all these numbers.
• Static JFrame instance: Your mF is a static variable, which breaks encapsulation. It's better to create the frame as an instance member or within a dedicated method, making your code more modular and testable.
• Calling another class's main() method: getMenuInJavaNow.main() is not a proper way to navigate between parts of your application. The main method is meant as the entry point of a program, not a regular method to trigger functionality. You should instantiate the target class or call a dedicated method instead.
• Monolithic main method: All your UI setup, event handling, and business logic are crammed into the main method. This makes the code hard to read, debug, and extend. You should split this into separate methods or even separate classes.
• Directly accessing other class's members: menuRecipients.recipientList != menuRecipients.fileNotFoundMessage assumes these are public members of DeliveryPackage. This violates encapsulation—you should use getter methods (like getRecipientList() or isFileFound()) instead.
• Unnecessary system property set: System.setProperty("sun.java2d.cmm", ...) is probably unnecessary unless you have a specific rendering issue. It's best to remove it unless you can justify its use.

Refactored Code with Proper Layout Managers #

Let's rewrite your menu using BorderLayout for the main frame, with a top panel for the title and a center panel for the buttons. This will make the UI resizable and maintainable:

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;

public class MainMenu {
    private JFrame mainFrame;
    private static final Font MENU_FONT = new Font("Courier", Font.BOLD, 16);
    private static final Color BLUE_STEEL = new Color(70, 107, 176);

    public static void main(String[] args) {
        // Run UI code on Swing's Event Dispatch Thread (required for thread safety)
        SwingUtilities.invokeLater(() -> new MainMenu().createAndShowUI());
    }

    private void createAndShowUI() {
        mainFrame = new JFrame("Main Menu");
        mainFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        mainFrame.setMinimumSize(new Dimension(465, 230)); // Set a minimum usable size
        mainFrame.getContentPane().setBackground(Color.WHITE);

        // Build and add UI components
        mainFrame.setLayout(new BorderLayout(10, 20));
        mainFrame.add(createTitlePanel(), BorderLayout.NORTH);
        mainFrame.add(createButtonPanel(), BorderLayout.CENTER);

        mainFrame.setLocationRelativeTo(null);
        mainFrame.setVisible(true);
    }

    private JPanel createTitlePanel() {
        JPanel panel = new JPanel(new GridBagLayout());
        panel.setBackground(BLUE_STEEL);
        panel.setBorder(BorderFactory.createEmptyBorder(10, 10, 10, 10)); // Add padding for better spacing

        JLabel titleLabel = new JLabel("Welcome to the menu GENERATORRRR");
        titleLabel.setFont(MENU_FONT);
        titleLabel.setForeground(Color.WHITE);

        panel.add(titleLabel);
        return panel;
    }

    private JPanel createButtonPanel() {
        JPanel panel = new JPanel(new FlowLayout(FlowLayout.CENTER, 20, 0));
        panel.setBackground(Color.WHITE);

        JButton generateButton = new JButton("Generate Menu");
        JButton manageRecipientsButton = new JButton("Manage Recipients");

        // Apply your button formatting
        menuUtilities.formatButton(generateButton);
        menuUtilities.formatButton(manageRecipientsButton);

        // Attach event handlers
        generateButton.addActionListener(this::handleGenerateMenu);
        manageRecipientsButton.addActionListener(this::handleManageRecipients);

        panel.add(generateButton);
        panel.add(manageRecipientsButton);
        return panel;
    }

    private void handleGenerateMenu(ActionEvent e) {
        System.out.println("Generate Menu pressed");
        mainFrame.dispose();
        // Replace this with proper instantiation instead of calling main()
        // new GetMenuInJavaNow().launch(); // Example of a better approach
        getMenuInJavaNow.main(); // Keeping your original call for now—refactor this later!
    }

    private void handleManageRecipients(ActionEvent e) {
        DeliveryPackage menuRecipients = new DeliveryPackage();
        // Use getter methods instead of direct member access (add these to DeliveryPackage)
        if (!menuRecipients.getRecipientList().equals(menuRecipients.getFileNotFoundMessage())) {
            editRecipientList(menuRecipients);
        } else {
            JOptionPane.showMessageDialog(mainFrame,
                    "File not found at " + menuRecipients.getRecipientFilePath(),
                    menuRecipients.getRecipientFileName() + " missing!",
                    JOptionPane.ERROR_MESSAGE);
        }
    }

    // Assume this method exists in your original code
    private void editRecipientList(DeliveryPackage recipients) {
        // Your implementation here
    }
}

Key Improvements in the Refactored Code #

• No null layout: Uses BorderLayout, GridBagLayout, and FlowLayout to handle component positioning automatically. The UI will now resize properly.
• Modular code: Split into dedicated methods for building UI sections and handling events, making the code easier to read and maintain.
• EDT compliance: Uses SwingUtilities.invokeLater() to run UI code on the Event Dispatch Thread, which is required for safe Swing applications.
• Encapsulation: Removed the static frame and replaced direct member access with getter calls (you'll need to add these getters to your DeliveryPackage class).
• Flexible sizing: Uses setMinimumSize() instead of a fixed size, letting users resize the window while keeping it usable.
• Better spacing: Added padding to the title panel with EmptyBorder for a cleaner look, no hardcoded positions needed.

内容的提问来源于stack exchange，提问作者GohanCZ