import java.util.Date;
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.border.*;

public class JOptionPaneTest {
    JFrame jf = new JFrame("测试JOptionPane");
    // 分别定义6个面板用于定义对话框的几种选项
    private ButtonPanel messagePanel;
    private ButtonPanel messageTypePanel;
    private ButtonPanel msgPanel;
    private ButtonPanel confirmPanel;
    private ButtonPanel optionsPanel;
    private ButtonPanel inputPanel;
    private String messageString = "消息区内容";
    private Icon messageIcon = new ImageIcon("ico/heart.png");
    private Object messageObject = new Date();
    private Component messageComponent = new JButton("组件消息");
    private JButton msgBn = new JButton("消息对话框");
    private JButton confrimBn = new JButton("确认对话框");
    private JButton inputBn = new JButton("输入对话框");
    private JButton optionBn = new JButton("选项对话框");

    public void init() {
        JPanel top = new JPanel();
        top.setBorder(new TitledBorder(new EtchedBorder(), "对话框的通用选项", TitledBorder.CENTER, TitledBorder.TOP));
        top.setLayout(new GridLayout(1, 2));
        // 消息类型Panel，该Panel中的选项决定对话框的图标
        messageTypePanel = new ButtonPanel("选择消息的类型", new String[] { "ERROR_MESSAGE", "INFORMATION_MESSAGE",
                "WARNING_MESSAGE", "QUESTION_MESSAGE", "PLAIN_MESSAGE" });
        // 消息内容类型的Panel，该Panel中的选项决定对话框的消息区的内容
        messagePanel = new ButtonPanel("选择消息内容的类型", new String[] { "字符串消息", "图标消息", "组件消息", "普通对象消息", "Object[]消息" });
        top.add(messageTypePanel);
        top.add(messagePanel);
        JPanel bottom = new JPanel();
        bottom.setBorder(new TitledBorder(new EtchedBorder(), "弹出不同的对话框", TitledBorder.CENTER, TitledBorder.TOP));
        bottom.setLayout(new GridLayout(1, 4));
        // 创建用于弹出消息对话框的Panel
        msgPanel = new ButtonPanel("消息对话框", null);
        msgBn.addActionListener(new ShowAction());
        msgPanel.add(msgBn);
        // 创建用于弹出确认对话框的Panel
        confirmPanel = new ButtonPanel("确认对话框",
                new String[] { "DEFAULT_OPTION", "YES_NO_OPTION", "YES_NO_CANCEL_OPTION", "OK_CANCEL_OPTION" });
        confrimBn.addActionListener(new ShowAction());
        confirmPanel.add(confrimBn);
        // 创建用于弹出输入对话框的Panel
        inputPanel = new ButtonPanel("输入对话框", new String[] { "单行文本框", "下拉列表选择框" });
        inputBn.addActionListener(new ShowAction());
        inputPanel.add(inputBn);
        // 创建用于弹出选项对话框的Panel
        optionsPanel = new ButtonPanel("选项对话框", new String[] { "字符串选项", "图标选项", "对象选项" });
        optionBn.addActionListener(new ShowAction());
        optionsPanel.add(optionBn);
        bottom.add(msgPanel);
        bottom.add(confirmPanel);
        bottom.add(inputPanel);
        bottom.add(optionsPanel);
        Box box = new Box(BoxLayout.Y_AXIS);
        box.add(top);
        box.add(bottom);
        jf.add(box);
        jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jf.pack();
        jf.setVisible(true);
    }

    // 根据用户选择返回选项类型
    private int getOptionType() {
        switch (confirmPanel.getSelection()) {
        case "DEFAULT_OPTION":
            return JOptionPane.DEFAULT_OPTION;
        case "YES_NO_OPTION":
            return JOptionPane.YES_NO_OPTION;
        case "YES_NO_CANCEL_OPTION":
            return JOptionPane.YES_NO_CANCEL_OPTION;
        default:
            return JOptionPane.OK_CANCEL_OPTION;
        }
    }

    // 根据用户选择返回消息
    private Object getMessage() {
        switch (messagePanel.getSelection()) {
        case "字符串消息":
            return messageString;
        case "图标消息":
            return messageIcon;
        case "组件消息":
            return messageComponent;
        case "普通对象消息":
            return messageObject;
        default:
            return new Object[] { messageString, messageIcon, messageObject, messageComponent };
        }
    }

    // 根据用户选择返回消息类型（决定图标区的图标）
    private int getDialogType() {
        switch (messageTypePanel.getSelection()) {
        case "ERROR_MESSAGE":
            return JOptionPane.ERROR_MESSAGE;
        case "INFORMATION_MESSAGE":
            return JOptionPane.INFORMATION_MESSAGE;
        case "WARNING_MESSAGE":
            return JOptionPane.WARNING_MESSAGE;
        case "QUESTION_MESSAGE":
            return JOptionPane.QUESTION_MESSAGE;
        default:
            return JOptionPane.PLAIN_MESSAGE;
        }
    }

    private Object[] getOptions() {
        switch (optionsPanel.getSelection()) {
        case "字符串选项":
            return new String[] { "a", "b", "c", "d" };
        case "图标选项":
            return new Icon[] { new ImageIcon("ico/1.gif"), new ImageIcon("ico/2.gif"), new ImageIcon("ico/3.gif"),
                    new ImageIcon("ico/4.gif") };
        default:
            return new Object[] { new Date(), new Date(), new Date() };
        }
    }

    // 为各按钮定义事件监听器
    private class ShowAction implements ActionListener {
        public void actionPerformed(ActionEvent event) {
            switch (event.getActionCommand()) {
            case "确认对话框":
                JOptionPane.showConfirmDialog(jf, getMessage(), "确认对话框", getOptionType(), getDialogType());
                break;
            case "输入对话框":
                if (inputPanel.getSelection().equals("单行文本框")) {
                    JOptionPane.showInputDialog(jf, getMessage(), "输入对话框", getDialogType());
                } else {
                    JOptionPane.showInputDialog(jf, getMessage(), "输入对话框", getDialogType(), null,
                            new String[] { "轻量级Java EE企业应用实战", "疯狂Java讲义" }, "疯狂Java讲义");
                }
                break;
            case "消息对话框":
                JOptionPane.showMessageDialog(jf, getMessage(), "消息对话框", getDialogType());
                break;
            case "选项对话框":
                JOptionPane.showOptionDialog(jf, getMessage(), "选项对话框", getOptionType(), getDialogType(), null,
                        getOptions(), "a");
                break;
            }
        }
    }

    public static void main(String[] args) {
        new JOptionPaneTest().init();
    }
}

// 定义一个JPanel类扩展类，该类的对象包含多个纵向排列的
// JRadioButton控件，且Panel扩展类可以指定一个字符串作为TitledBorder
class ButtonPanel extends JPanel {
    private ButtonGroup group;

    public ButtonPanel(String title, String[] options) {
        setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), title));
        setLayout(new BoxLayout(this, BoxLayout.Y_AXIS));
        group = new ButtonGroup();
        for (int i = 0; options != null && i < options.length; i++) {
            JRadioButton b = new JRadioButton(options[i]);
            b.setActionCommand(options[i]);
            add(b);
            group.add(b);
            b.setSelected(i == 0);
        }
    }

    // 定义一个方法，用于返回用户选择的选项
    public String getSelection() {
        return group.getSelection().getActionCommand();
    }
}

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

public class HandDraw {
    // 画图区的宽度
    private final int AREA_WIDTH = 500;
    // 画图区的高度
    private final int AREA_HEIGHT = 400;
    // 下面的preX、preY保存了上一次鼠标拖动事件的鼠标坐标
    private int preX = -1;
    private int preY = -1;
    // 定义一个右键菜单用于设置画笔颜色
    JPopupMenu pop = new JPopupMenu();
    JMenuItem chooseColor = new JMenuItem("选择颜色");
    // 定义一个BufferedImage对象
    BufferedImage image = new BufferedImage(AREA_WIDTH, AREA_HEIGHT, BufferedImage.TYPE_INT_RGB);
    // 获取image对象的Graphics
    Graphics g = image.getGraphics();
    private JFrame f = new JFrame("简单手绘程序");
    private DrawCanvas drawArea = new DrawCanvas();
    // 用于保存画笔颜色
    private Color foreColor = new Color(255, 0, 0);

    public void init() {
        chooseColor.addActionListener(ae -> {
            // 下面代码直接弹出一个模式的颜色选择对话框，并返回用户选择的颜色
            // 1号代码
            // foreColor = JColorChooser.showDialog(f, "选择画笔颜色", foreColor);
            // 下面代码则弹出一个非模式的颜色选择对话框，
            // 并可以分别为“确定”按钮、“取消”按钮指定事件监听器
            // 2号代码 开始
            final JColorChooser colorPane = new JColorChooser(foreColor);
            JDialog jd = JColorChooser.createDialog(f, "选择画笔颜色", false, colorPane,
                    e -> foreColor = colorPane.getColor(), null);
            // 2号代码 结束
            jd.setVisible(true);
        });
        // 将菜单项组合成右键菜单
        pop.add(chooseColor);
        // 将右键菜单添加到drawArea对象中
        drawArea.setComponentPopupMenu(pop);
        // 将image对象的背景色填充成白色
        g.fillRect(0, 0, AREA_WIDTH, AREA_HEIGHT);
        drawArea.setPreferredSize(new Dimension(AREA_WIDTH, AREA_HEIGHT));
        // 监听鼠标移动动作
        drawArea.addMouseMotionListener(new MouseMotionAdapter() {
            // 实现按下鼠标键并拖动的事件处理器
            public void mouseDragged(MouseEvent e) {
                // 如果preX和preY大于0
                if (preX > 0 && preY > 0) {
                    // 设置当前颜色
                    g.setColor(foreColor);
                    // 绘制从上一次鼠标拖动事件点到本次鼠标拖动事件点的线段
                    g.drawLine(preX, preY, e.getX(), e.getY());
                }
                // 将当前鼠标事件点的X、Y坐标保存起来
                preX = e.getX();
                preY = e.getY();
                // 重绘drawArea对象
                drawArea.repaint();
            }
        });
        // 监听鼠标事件
        drawArea.addMouseListener(new MouseAdapter() {
            // 实现鼠标松开的事件处理器
            public void mouseReleased(MouseEvent e) {
                // 松开鼠标键时，把上一次鼠标拖动事件的X、Y坐标设为-1。
                preX = -1;
                preY = -1;
            }
        });
        f.add(drawArea);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.pack();
        f.setVisible(true);
    }

    public static void main(String[] args) {
        new HandDraw().init();
    }

    // 让画图区域继承JPanel类
    class DrawCanvas extends JPanel {
        private static final long serialVersionUID = -3097175472553624890L;

        // 重写JPanel的paint方法，实现绘画
        public void paint(Graphics g) {
            // 将image绘制到该组件上
            g.drawImage(image, 0, 0, null);
        }
    }
}

//以当前路径创建文件选择器
JFileChooser chooser = new JFileChooser(".");

//默认选择当前路径下的123.jpg文件
chooser.setSelectedFile(new File("123.jpg"));

// 设置既可选择文件，也可选择路径
chooser.setFileselectionMode (JFileChooser.FILES_AND_DIRECTORIES);

public boolean accept(File f){
    //如果该文件是路径，则接受该文件
    if (f.isDirectory())
        return true;
    // 只接受以.gif作为后缀的文件
    if (f.getName().endswith(".gif"))
        return true;
    return false;
}

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

public class JToolBarTest {
    JFrame jFrame = new JFrame("测试工具条");
    JTextArea jTextArea = new JTextArea(6, 35);
    JToolBar jToolBar = new JToolBar();
    JMenuBar jMenuBar = new JMenuBar();
    JMenu editMenu = new JMenu("编辑");
    // 获取系统剪贴板
    Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
    // 创建"粘贴"Action，该Action用于创建菜单项、工具按钮和普通按钮
    Action pasteAction = new AbstractAction("粘贴", new ImageIcon("ico/paste.png")) {
        private static final long serialVersionUID = 3517594171860327637L;

        public void actionPerformed(ActionEvent e) {
            // 如果剪贴板中包含stringFlavor内容
            if (clipboard.isDataFlavorAvailable(DataFlavor.stringFlavor)) {
                try {
                    // 取出剪贴板中stringFlavor内容
                    String content = (String) clipboard.getData(DataFlavor.stringFlavor);
                    // 将选中内容替换成剪贴板中的内容
                    jTextArea.replaceRange(content, jTextArea.getSelectionStart(), jTextArea.getSelectionEnd());
                } catch (Exception ee) {
                    ee.printStackTrace();
                }
            }
        }
    };
    // 创建"复制"Action
    Action copyAction = new AbstractAction("复制", new ImageIcon("ico/copy.png")) {
        private static final long serialVersionUID = 8903877264455460708L;

        public void actionPerformed(ActionEvent e) {
            StringSelection contents = new StringSelection(jTextArea.getSelectedText());
            // 将StringSelection对象放入剪贴板
            clipboard.setContents(contents, null);
            // 如果剪贴板中包含stringFlavor内容
            if (clipboard.isDataFlavorAvailable(DataFlavor.stringFlavor)) {
                // 将pasteAction激活
                pasteAction.setEnabled(true);
            }
        }
    };

    public void init() {
        // pasteAction默认处于不激活状态
        pasteAction.setEnabled(false); // 1 
        jFrame.add(new JScrollPane(jTextArea));
        // 以Action创建按钮，并将该按钮添加到Panel中
        JButton copyBn = new JButton(copyAction);
        JButton pasteBn = new JButton(pasteAction);
        JPanel jp = new JPanel();
        jp.add(copyBn);
        jp.add(pasteBn);
        jFrame.add(jp, BorderLayout.SOUTH);
        // 向工具条中添加Action对象，该对象将会转换成工具按钮
        jToolBar.add(copyAction);
        jToolBar.addSeparator();
        jToolBar.add(pasteAction);
        // 向菜单中添加Action对象，该对象将会转换成菜单项
        editMenu.add(copyAction);
        editMenu.add(pasteAction);
        // 将edit菜单添加到菜单条中
        jMenuBar.add(editMenu);
        jFrame.setJMenuBar(jMenuBar);
        // 设置工具条和工具按钮之间的页边距。
        jToolBar.setMargin(new Insets(5, 5, 5, 5)); // 2
        // 向窗口中添加工具条
        jFrame.add(jToolBar, BorderLayout.NORTH);
        jFrame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        jFrame.pack();
        jFrame.setVisible(true);
    }

    public static void main(String[] args) {
        new JToolBarTest().init();
    }
}

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

public class BindKeyTest {
    // 定义窗体
    JFrame jFrame = new JFrame("测试键盘绑定");
    // 文本域
    JTextArea jTextArea = new JTextArea(5, 30);
    // 按钮
    JButton jButton = new JButton("发送");
    // 文本框
    JTextField jTextField = new JTextField(15);

    public void init() {
        // 添加文本框到窗体中
        jFrame.add(jTextArea);
        // 创建一个面板
        JPanel jp = new JPanel();
        // 添加文本框到面板中
        jp.add(jTextField);
        // 添加按钮到文本框中
        jp.add(jButton);
        // 添加面包到窗体的南边(上北下南)
        jFrame.add(jp, BorderLayout.SOUTH);

        // 创建一个Action
        // 发送消息的Action,Action是ActionListener的子接口
        Action sendMsg = new AbstractAction() {
            // 设置序列号值
            private static final long serialVersionUID = 2625520225836946219L;
            // 实现方法
            public void actionPerformed(ActionEvent e) {
                // 把文本框中的文本追加到文本域中
                jTextArea.append(jTextField.getText() + "\n");
                // 清空文本框中的内容
                jTextField.setText("");
            }
        };
        // 添加事件监听器
        jButton.addActionListener(sendMsg);

        // 将Ctrl+Enter键和 字符串"send" 关联
        jTextField.getInputMap().put(KeyStroke.getKeyStroke('\n', java.awt.event.InputEvent.CTRL_DOWN_MASK), "send");
        // 将 字符串 "send" 和sendMsg这个Action关联
        jTextField.getActionMap().put("send", sendMsg);

        // 以最小方式显示窗体
        jFrame.pack();
        // 设置窗体可见
        jFrame.setVisible(true);
    }

    public static void main(String[] args) {
        new BindKeyTest().init();
    }
}

import javax.swing.*;
import javax.swing.border.*;
import java.awt.*;

public class BorderTest {
    private JFrame jf = new JFrame("测试边框");

    public void init() {
        jf.setLayout(new GridLayout(2, 4));
        // 使用静态工厂方法创建BevelBorder
        Border bb = BorderFactory.createBevelBorder(BevelBorder.RAISED, Color.RED, Color.GREEN, Color.BLUE, Color.GRAY);
        jf.add(getPanelWithBorder(bb, "BevelBorder"));
        // 使用静态工厂方法创建LineBorder
        Border lb = BorderFactory.createLineBorder(Color.ORANGE, 10);
        jf.add(getPanelWithBorder(lb, "LineBorder"));
        // 使用静态工厂方法创建EmptyBorder，EmptyBorder就是在组件四周留空
        Border eb = BorderFactory.createEmptyBorder(20, 5, 10, 30);
        jf.add(getPanelWithBorder(eb, "EmptyBorder"));
        // 使用静态工厂方法创建EtchedBorder
        Border etb = BorderFactory.createEtchedBorder(EtchedBorder.RAISED, Color.RED, Color.GREEN);
        jf.add(getPanelWithBorder(etb, "EtchedBorder"));
        // 直接创建TitledBorder，TitledBorder边框就是为原有的边框增加标题
        TitledBorder tb = new TitledBorder(lb, "测试标题", TitledBorder.LEFT, TitledBorder.BOTTOM,
                new Font("StSong", Font.BOLD, 18), Color.BLUE);
        jf.add(getPanelWithBorder(tb, "TitledBorder"));
        // 直接创建MatteBorder，MatteBorder边框是EmptyBorder的子类，
        // 它可以指定留空区域的颜色或背景，此处是指定颜色
        MatteBorder mb = new MatteBorder(20, 5, 10, 30, Color.GREEN);
        jf.add(getPanelWithBorder(mb, "MatteBorder"));
        // 直接创建CompoundBorder，CompoundBorder边框将两个边框组合成新边框
        CompoundBorder cb = new CompoundBorder(new LineBorder(Color.RED, 8), tb);
        jf.add(getPanelWithBorder(cb, "CompoundBorder"));
        jf.pack();
        jf.setVisible(true);
    }

    public static void main(String[] args) {
        new BorderTest().init();
    }

    public JPanel getPanelWithBorder(Border b, String BorderName) {
        JPanel p = new JPanel();
        p.add(new JLabel(BorderName));
        // 为Panel组件设置边框
        p.setBorder(b);
        return p;
    }
}

try{
    //设置使用Windows风格
    UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.windowsLookAndFeel");
    // 通过更新f容器以及f容器里所有组件的UI
    SwingUtilities.updateComponentTreeUI(f);
}
catch(Exception e){
    e.printstackTrace();
}

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

public class SwingComponent {
    JFrame f = new JFrame("测试");
    // 定义一个按钮,并为之指定图标
    Icon okIcon = new ImageIcon("ico/ok.png");
    JButton ok = new JButton("确认", okIcon);
    // 定义一个单选按钮，初始处于选中状态
    JRadioButton male = new JRadioButton("男", true);
    // 定义一个单选按钮，初始处于没有选中状态
    JRadioButton female = new JRadioButton("女", false);
    // 定义一个ButtonGroup，用于将上面两个JRadioButton组合在一起
    ButtonGroup bg = new ButtonGroup();
    // 定义一个复选框，初始处于没有选中状态。
    JCheckBox married = new JCheckBox("是否已婚？", false);
    String[] colors = new String[] { "红色", "绿色", "蓝色" };
    // 定义一个下拉选择框
    JComboBox<String> colorChooser = new JComboBox<>(colors);
    // 定义一个列表选择框
    JList<String> colorList = new JList<>(colors);
    // 定义一个8行、20列的多行文本域
    JTextArea ta = new JTextArea(8, 20);
    // 定义一个40列的单行文本域
    JTextField name = new JTextField(40);
    JMenuBar mb = new JMenuBar();
    JMenu file = new JMenu("文件");
    JMenu edit = new JMenu("编辑");
    // 创建“新建”菜单项，并为之指定图标
    Icon newIcon = new ImageIcon("ico/new.png");
    JMenuItem newItem = new JMenuItem("新建", newIcon);
    // 创建“保存”菜单项，并为之指定图标
    Icon saveIcon = new ImageIcon("ico/save.png");
    JMenuItem saveItem = new JMenuItem("保存", saveIcon);
    // 创建“退出”菜单项，并为之指定图标
    Icon exitIcon = new ImageIcon("ico/exit.png");
    JMenuItem exitItem = new JMenuItem("退出", exitIcon);
    JCheckBoxMenuItem autoWrap = new JCheckBoxMenuItem("自动换行");
    // 创建“复制”菜单项，并为之指定图标
    JMenuItem copyItem = new JMenuItem("复制", new ImageIcon("ico/copy.png"));
    // 创建“粘贴”菜单项，并为之指定图标
    JMenuItem pasteItem = new JMenuItem("粘贴", new ImageIcon("ico/paste.png"));
    JMenu format = new JMenu("格式");
    JMenuItem commentItem = new JMenuItem("注释");
    JMenuItem cancelItem = new JMenuItem("取消注释");
    // 定义一个右键菜单用于设置程序风格
    JPopupMenu pop = new JPopupMenu();
    // 用于组合三个风格菜单项的ButtonGroup
    ButtonGroup flavorGroup = new ButtonGroup();
    // 创建五个单选框按钮，用于设定程序的外观风格
    JRadioButtonMenuItem metalItem = new JRadioButtonMenuItem("Metal风格", true);
    JRadioButtonMenuItem nimbusItem = new JRadioButtonMenuItem("Nimbus风格");
    JRadioButtonMenuItem windowsItem = new JRadioButtonMenuItem("Windows风格");
    JRadioButtonMenuItem classicItem = new JRadioButtonMenuItem("Windows经典风格");
    JRadioButtonMenuItem motifItem = new JRadioButtonMenuItem("Motif风格");

    // -----------------用于执行界面初始化的init方法---------------------
    public void init() {
        // 创建一个装载了文本框、按钮的JPanel
        JPanel bottom = new JPanel();
        bottom.add(name);
        bottom.add(ok);
        f.add(bottom, BorderLayout.SOUTH);
        // 创建一个装载了下拉选择框、三个JCheckBox的JPanel
        JPanel checkPanel = new JPanel();
        checkPanel.add(colorChooser);
        bg.add(male);
        bg.add(female);
        checkPanel.add(male);
        checkPanel.add(female);
        checkPanel.add(married);
        // 创建一个垂直排列组件的Box，盛装多行文本域JPanel
        Box topLeft = Box.createVerticalBox();
        // 使用JScrollPane作为普通组件的JViewPort
        JScrollPane taJsp = new JScrollPane(ta); // ⑤
        topLeft.add(taJsp);
        topLeft.add(checkPanel);
        // 创建一个水平排列组件的Box，盛装topLeft、colorList
        Box top = Box.createHorizontalBox();
        top.add(topLeft);
        top.add(colorList);
        // 将top Box容器添加到窗口的中间
        f.add(top);
        // -----------下面开始组合菜单、并为菜单添加监听器----------
        // 为newItem设置快捷键，设置快捷键时要使用大写字母
        newItem.setAccelerator(KeyStroke.getKeyStroke('N', InputEvent.CTRL_MASK)); // 1号代码
        newItem.addActionListener(e -> ta.append("用户单击了“新建”菜单\n"));
        // 为file菜单添加菜单项
        file.add(newItem);
        file.add(saveItem);
        file.add(exitItem);
        // 为edit菜单添加菜单项
        edit.add(autoWrap);
        // 使用addSeparator方法来添加菜单分隔线
        edit.addSeparator();
        edit.add(copyItem);
        edit.add(pasteItem);
        // 为commentItem组件添加提示信息
        commentItem.setToolTipText("将程序代码注释起来！");
        // 为format菜单添加菜单项
        format.add(commentItem);
        format.add(cancelItem);
        // 使用添加new JMenuItem("-")的方式不能添加菜单分隔符
        edit.add(new JMenuItem("-"));
        // 将format菜单组合到edit菜单中，从而形成二级菜单
        edit.add(format);
        // 将file、edit菜单添加到mb菜单条中
        mb.add(file);
        mb.add(edit);
        // 为f窗口设置菜单条
        f.setJMenuBar(mb);
        // -----------下面开始组合右键菜单、并安装右键菜单----------
        flavorGroup.add(metalItem);
        flavorGroup.add(nimbusItem);
        flavorGroup.add(windowsItem);
        flavorGroup.add(classicItem);
        flavorGroup.add(motifItem);
        pop.add(metalItem);
        pop.add(nimbusItem);
        pop.add(windowsItem);
        pop.add(classicItem);
        pop.add(motifItem);
        // 为5个风格菜单创建事件监听器
        ActionListener flavorListener = e -> {
            try {
                switch (e.getActionCommand()) {
                case "Metal风格":
                    changeFlavor(1);
                    break;
                case "Nimbus风格":
                    changeFlavor(2);
                    break;
                case "Windows风格":
                    changeFlavor(3);
                    break;
                case "Windows经典风格":
                    changeFlavor(4);
                    break;
                case "Motif风格":
                    changeFlavor(5);
                    break;
                }
            } catch (Exception ee) {
                ee.printStackTrace();
            }
        };
        // 为五个风格菜单项添加事件监听器
        metalItem.addActionListener(flavorListener);
        nimbusItem.addActionListener(flavorListener);
        windowsItem.addActionListener(flavorListener);
        classicItem.addActionListener(flavorListener);
        motifItem.addActionListener(flavorListener);
        // 调用该方法即可设置右键菜单，无须使用事件机制
        ta.setComponentPopupMenu(pop); // 4号代码
        // 设置关闭窗口时，退出程序
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.pack();
        f.setVisible(true);
    }

    // 定义一个方法，用于改变界面风格
    private void changeFlavor(int flavor) throws Exception {
        switch (flavor) {
        // 设置Metal风格
        case 1:
            UIManager.setLookAndFeel("javax.swing.plaf.metal.MetalLookAndFeel");
            break;
        // 设置Nimbus风格
        case 2:
            UIManager.setLookAndFeel("javax.swing.plaf.nimbus.NimbusLookAndFeel");
            break;
        // 设置Windows风格
        case 3:
            UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsLookAndFeel");
            break;
        // 设置Windows经典风格
        case 4:
            UIManager.setLookAndFeel("com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel");
            break;
        // 设置Motif风格
        case 5:
            UIManager.setLookAndFeel("com.sun.java.swing.plaf.motif.MotifLookAndFeel");
            break;
        }
        // 更新f窗口内顶级容器以及内部所有组件的UI
        SwingUtilities.updateComponentTreeUI(f.getContentPane()); // 2号代码
        // 更新mb菜单条以及内部所有组件的UI
        SwingUtilities.updateComponentTreeUI(mb);
        // 更新pop右键菜单以及内部所有组件的UI
        SwingUtilities.updateComponentTreeUI(pop);
    }

    public static void main(String[] args) {
        // 设置Swing窗口使用Java风格
        // JFrame.setDefaultLookAndFeelDecorated(true); //3号代码
        new SwingComponent().init();
    }
}

import javax.swing.*;

public class AllLookAndFeel {
    public static void main(String[] args) {
        System.out.println("当前系统可用的所有LAF:");
        for (UIManager.LookAndFeelInfo info : UIManager.getInstalledLookAndFeels()) {
            System.out.println(info.getName() + "--->" + info);
        }
    }
}

Metal--->javax.swing.UIManager$LookAndFeelInfo[Metal javax.swing.plaf.metal.MetalLookAndFeel]
Nimbus--->javax.swing.UIManager$LookAndFeelInfo[Nimbus javax.swing.plaf.nimbus.NimbusLookAndFeel]
CDE/Motif--->javax.swing.UIManager$LookAndFeelInfo[CDE/Motif com.sun.java.swing.plaf.motif.MotifLookAndFeel]
Windows--->javax.swing.UIManager$LookAndFeelInfo[Windows com.sun.java.swing.plaf.windows.WindowsLookAndFeel]
Windows Classic--->javax.swing.UIManager$LookAndFeelInfo[Windows Classic com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel]