Java 记事本-窗体程序有详细设计文档和报告

╰+哭是因爲堅強的太久メ 2024-03-27 15:54 12阅读 0赞

## 开发环境 ##

开发语言为Java，开发环境Eclipse或者IDEA都可以，无数据库。运行主JAVA文件，或者执行打开JAR文件即可以运行本程序。

## 系统框架 ##

利用JDK自带的SWING框架开发，不需要安装第三方JAR包。纯窗体模式，直接运行Main文件即可以。同时带有详细得设计文档。

## 主要功能 ##

课程设计主要通过编写一个简单的记事本程序使我们深入理解并实践在本课程中所学的有关Java程序设计方面的语言基础、异常处理、事件处理、小应用程序以及图形用户界面设计等内容。要求程序有合理的界面设计，能够进行输入文字操作，并具有新建、打开、保存文件，复制、粘贴、剪切，退出等功能，界面美观。具体如下：

1．新建操作

用户可以根据需要，建立新的记事本文档，进行操作。

2．打开操作

用户在可以打开任何文本内容进行操作。

3．保存操作

用户在对文本操作进行以后，可以按照需求进行保存操作。

4．撤销操作

若文本内容不符合用户的需求，可以撤销当前的操作。

5．剪切操作

用户可以可按照需求，对需要的内容进行剪切，将其移植其他处。

6．复制操作

移植的内容可以进行复制，这样更方便用户修改相应内容。

7．粘贴操作

将要复制的内容进行粘贴。

8．删除操作

删除不需要的内容。

9．查找操作

该功能为了方便用户进行查找文本内容中需要的内容。

10．替换操作

用户根据需要选择自己需要替换的内容，方便使用。

11．全选操作

全选内容方便用户进行相应的剪切，复制，粘贴等内容。

12．格式操作

用户可根据需求将文本内容进行字体设置。

13．退出操作

用户不需要进行任何操作时候，可以退出。

## 功能效果 ##

![32ff1218b713d6920b9df1f387a7d4cf.png][]

![3f0e9ebc376cb978ed4a4f9a5f1aab92.png][]

![679732e0edf0d8bdfa67be89817ac174.png][]

![0aa0fb80dd195a604123c9975e3b04fb.png][]

![71ac33f393246018773329a5a91bc4f6.png][]

## 关键代码 ##

package com.txt;
    import java.awt.*;
    import java.awt.event.*;
    import java.util.*;
    import java.io.*;
    import javax.swing.undo.*;
    import javax.swing.*;
    import javax.swing.event.*;
    import java.awt.datatransfer.*;
    public class Notepad extends JFrame implements ActionListener, DocumentListener { // 菜单
        JMenu fileMenu, editMenu, formatMenu, viewMenu, helpMenu,settingMenu;
        // 右键弹出菜单项
        JPopupMenu popupMenu;
        JMenuItem popupMenu_Undo, popupMenu_Cut, popupMenu_Copy, popupMenu_Paste,
                popupMenu_Delete, popupMenu_SelectAll;
        // “文件”的菜单项
        JMenuItem fileMenu_New, fileMenu_Open, fileMenu_Save, fileMenu_SaveAs,
                 fileMenu_Exit;
        // “编辑”的菜单项
        JMenuItem editMenu_Undo, editMenu_Cut, editMenu_Copy, editMenu_Paste,
                editMenu_Delete, editMenu_Find, editMenu_FindNext,
                editMenu_Replace, editMenu_GoTo, editMenu_SelectAll,
                editMenu_TimeDate;
        // “格式”的菜单项
        JCheckBoxMenuItem formatMenu_LineWrap;
        JMenuItem formatMenu_Font;
        // “查看”的菜单项
        JCheckBoxMenuItem viewMenu_Status;
        // “帮助”的菜单项
        
        
        JMenuItem tongjiMenu, qianjinMenu,backgroudMenu;
        
        JMenuItem helpMenu_HelpTopics, helpMenu_AboutNotepad;
        // “文本”编辑区域
        JTextArea editArea;
        // 状态栏标签
        JLabel statusLabel;
        // 系统剪贴板
        Toolkit toolkit = Toolkit.getDefaultToolkit();
        Clipboard clipBoard = toolkit.getSystemClipboard();
        // 创建撤销操作管理器(与撤销操作有关)
        protected UndoManager undo = new UndoManager();
        protected UndoableEditListener undoHandler = new UndoHandler();
        // 其他变量
        String oldValue;// 存放编辑区原来的内容，用于比较文本是否有改动
        boolean isNewFile = true;// 是否新文件(未保存过的)
        File currentFile;// 当前文件名
    
        // 构造函数开始
        public Notepad() {
            super("Java Swing记事本程序");
            // 改变系统默认字体
            Font font = new Font("Dialog", Font.PLAIN, 12);
            java.util.Enumeration keys = UIManager.getDefaults().keys();
            while (keys.hasMoreElements()) {
                Object key = keys.nextElement();
                Object value = UIManager.get(key);
                if (value instanceof javax.swing.plaf.FontUIResource) {
                    UIManager.put(key, font);
                }
            }
            // 创建菜单条
            JMenuBar menuBar = new JMenuBar();
            // 创建文件菜单及菜单项并注册事件监听
            fileMenu = new JMenu("文件(F)");
            fileMenu.setMnemonic('F');// 设置快捷键ALT+F
    
            fileMenu_New = new JMenuItem("新建(N)");
            fileMenu_New.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_N,
                    InputEvent.CTRL_MASK));
            fileMenu_New.addActionListener(this);
    
            fileMenu_Open = new JMenuItem("打开(O)...");
            fileMenu_Open.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_O,
                    InputEvent.CTRL_MASK));
            fileMenu_Open.addActionListener(this);
    
            fileMenu_Save = new JMenuItem("保存(S)");
            fileMenu_Save.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_S,
                    InputEvent.CTRL_MASK));
            fileMenu_Save.addActionListener(this);
    
            fileMenu_SaveAs = new JMenuItem("另存为(A)...");
            fileMenu_SaveAs.addActionListener(this);
    
            fileMenu_Exit = new JMenuItem("退出(X)");
            fileMenu_Exit.addActionListener(this);
    
            // 创建编辑菜单及菜单项并注册事件监听
            editMenu = new JMenu("编辑(E)");
            editMenu.setMnemonic('E');// 设置快捷键ALT+E
            // 当选择编辑菜单时，设置剪切、复制、粘贴、删除等功能的可用性
            editMenu.addMenuListener(new MenuListener() {
                public void menuCanceled(MenuEvent e)// 取消菜单时调用
                {
                    checkMenuItemEnabled();// 设置剪切、复制、粘贴、删除等功能的可用性
                }
    
                public void menuDeselected(MenuEvent e)// 取消选择某个菜单时调用
                {
                    checkMenuItemEnabled();// 设置剪切、复制、粘贴、删除等功能的可用性
                }
    
                public void menuSelected(MenuEvent e)// 选择某个菜单时调用
                {
                    checkMenuItemEnabled();// 设置剪切、复制、粘贴、删除等功能的可用性
                }
            });
    
            editMenu_Undo = new JMenuItem("撤销(U)");
            editMenu_Undo.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_Z,
                    InputEvent.CTRL_MASK));
            editMenu_Undo.addActionListener(this);
            editMenu_Undo.setEnabled(false);
    
            editMenu_Cut = new JMenuItem("剪切(T)");
            editMenu_Cut.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_X,
                    InputEvent.CTRL_MASK));
            editMenu_Cut.addActionListener(this);
    
            editMenu_Copy = new JMenuItem("复制(C)");
            editMenu_Copy.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_C,
                    InputEvent.CTRL_MASK));
            editMenu_Copy.addActionListener(this);
    
            editMenu_Paste = new JMenuItem("粘贴(P)");
            editMenu_Paste.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_V,
                    InputEvent.CTRL_MASK));
            editMenu_Paste.addActionListener(this);
    
            editMenu_Delete = new JMenuItem("删除(D)");
            editMenu_Delete.setAccelerator(KeyStroke.getKeyStroke(
                    KeyEvent.VK_DELETE, 0));
            editMenu_Delete.addActionListener(this);
    
            editMenu_Find = new JMenuItem("查找(F)...");
            editMenu_Find.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F,
                    InputEvent.CTRL_MASK));
            editMenu_Find.addActionListener(this);
    
            editMenu_FindNext = new JMenuItem("查找下一个(N)");
            editMenu_FindNext.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F3,
                    0));
            editMenu_FindNext.addActionListener(this);
    
            editMenu_Replace = new JMenuItem("替换(R)...", 'R');
            editMenu_Replace.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_H,
                    InputEvent.CTRL_MASK));
            editMenu_Replace.addActionListener(this);
    
            editMenu_GoTo = new JMenuItem("转到(G)...", 'G');
            editMenu_GoTo.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_G,
                    InputEvent.CTRL_MASK));
            editMenu_GoTo.addActionListener(this);
    
            editMenu_SelectAll = new JMenuItem("全选", 'A');
            editMenu_SelectAll.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_A,
                    InputEvent.CTRL_MASK));
            editMenu_SelectAll.addActionListener(this);
    
            editMenu_TimeDate = new JMenuItem("时间/日期(D)", 'D');
            editMenu_TimeDate.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_F5,
                    0));
            editMenu_TimeDate.addActionListener(this);
    
            // 创建格式菜单及菜单项并注册事件监听
            formatMenu = new JMenu("格式(O)");
            formatMenu.setMnemonic('O');// 设置快捷键ALT+O
    
            formatMenu_LineWrap = new JCheckBoxMenuItem("自动换行(W)");
            formatMenu_LineWrap.setMnemonic('W');// 设置快捷键ALT+W
            formatMenu_LineWrap.setState(true);
            formatMenu_LineWrap.addActionListener(this);
    
            formatMenu_Font = new JMenuItem("字体(F)...");
            formatMenu_Font.addActionListener(this);
    
            // 创建查看菜单及菜单项并注册事件监听
            viewMenu = new JMenu("查看(V)");
            viewMenu.setMnemonic('V');// 设置快捷键ALT+V
    
            viewMenu_Status = new JCheckBoxMenuItem("状态栏(S)");
            viewMenu_Status.setMnemonic('S');// 设置快捷键ALT+S
            viewMenu_Status.setState(true);
            viewMenu_Status.addActionListener(this);
    
            
            settingMenu=new JMenu("设置菜单");
            tongjiMenu = new JMenuItem("字数统计");
            tongjiMenu.addActionListener(this);
    
            qianjinMenu = new JMenuItem("前景设置");
            qianjinMenu.addActionListener(this);
            
            backgroudMenu = new JMenuItem("背景设置");
            backgroudMenu.addActionListener(this);
            
            
            // 创建帮助菜单及菜单项并注册事件监听
            helpMenu = new JMenu("帮助(H)");
            helpMenu.setMnemonic('H');// 设置快捷键ALT+H
    
            helpMenu_HelpTopics = new JMenuItem("查看帮助(H)");
            helpMenu_HelpTopics.setAccelerator(KeyStroke.getKeyStroke(
                    KeyEvent.VK_F1, 0));
            helpMenu_HelpTopics.addActionListener(this);
    
            helpMenu_AboutNotepad = new JMenuItem("关于记事本(A)");
            helpMenu_AboutNotepad.addActionListener(this);
    
            // 向菜单条添加"文件"菜单及菜单项
            menuBar.add(fileMenu);
            fileMenu.add(fileMenu_New);
            fileMenu.add(fileMenu_Open);
            fileMenu.add(fileMenu_Save);
            fileMenu.add(fileMenu_SaveAs);
            fileMenu.addSeparator(); // 分隔线
            
            fileMenu.add(fileMenu_Exit);
    
            // 向菜单条添加"编辑"菜单及菜单项
            menuBar.add(editMenu);
            editMenu.add(editMenu_Undo);
            editMenu.addSeparator(); // 分隔线
            editMenu.add(editMenu_Cut);
            editMenu.add(editMenu_Copy);
            editMenu.add(editMenu_Paste);
            editMenu.add(editMenu_Delete);
            editMenu.addSeparator(); // 分隔线
            editMenu.add(editMenu_Find);
            editMenu.add(editMenu_FindNext);
            editMenu.add(editMenu_Replace);
            editMenu.add(editMenu_GoTo);
            editMenu.addSeparator(); // 分隔线
            editMenu.add(editMenu_SelectAll);
            editMenu.add(editMenu_TimeDate);
    
            // 向菜单条添加"格式"菜单及菜单项
            menuBar.add(formatMenu);
            formatMenu.add(formatMenu_LineWrap);
            formatMenu.add(formatMenu_Font);
    
            // 向菜单条添加"查看"菜单及菜单项
            menuBar.add(viewMenu);
            viewMenu.add(viewMenu_Status);
    
            menuBar.add(settingMenu);
            settingMenu.add(tongjiMenu);
            settingMenu.add(qianjinMenu);
            settingMenu.add(backgroudMenu);
            
            // 向菜单条添加"帮助"菜单及菜单项
            menuBar.add(helpMenu);
            helpMenu.add(helpMenu_HelpTopics);
            helpMenu.addSeparator();
            helpMenu.add(helpMenu_AboutNotepad);
    
            // 向窗口添加菜单条
            this.setJMenuBar(menuBar);
    
            // 创建文本编辑区并添加滚动条
            editArea = new JTextArea(20, 50);
            JScrollPane scroller = new JScrollPane(editArea);
            scroller.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
            this.add(scroller, BorderLayout.CENTER);// 向窗口添加文本编辑区
            editArea.setWrapStyleWord(true);// 设置单词在一行不足容纳时换行
            editArea.setLineWrap(true);// 设置文本编辑区自动换行默认为true,即会"自动换行"
            // this.add(editArea,BorderLayout.CENTER);//向窗口添加文本编辑区
            oldValue = editArea.getText();// 获取原文本编辑区的内容
    
            // 编辑区注册事件监听(与撤销操作有关)
            editArea.getDocument().addUndoableEditListener(undoHandler);
            editArea.getDocument().addDocumentListener(this);
    
            // 创建右键弹出菜单
            popupMenu = new JPopupMenu();
            popupMenu_Undo = new JMenuItem("撤销(U)");
            popupMenu_Cut = new JMenuItem("剪切(T)");
            popupMenu_Copy = new JMenuItem("复制(C)");
            popupMenu_Paste = new JMenuItem("粘帖(P)");
            popupMenu_Delete = new JMenuItem("删除(D)");
            popupMenu_SelectAll = new JMenuItem("全选(A)");
    
            popupMenu_Undo.setEnabled(false);
    
            // 向右键菜单添加菜单项和分隔符
            popupMenu.add(popupMenu_Undo);
            popupMenu.addSeparator();
            popupMenu.add(popupMenu_Cut);
            popupMenu.add(popupMenu_Copy);
            popupMenu.add(popupMenu_Paste);
            popupMenu.add(popupMenu_Delete);
            popupMenu.addSeparator();
            popupMenu.add(popupMenu_SelectAll);
    
            // 文本编辑区注册右键菜单事件
            popupMenu_Undo.addActionListener(this);
            popupMenu_Cut.addActionListener(this);
            popupMenu_Copy.addActionListener(this);
            popupMenu_Paste.addActionListener(this);
            popupMenu_Delete.addActionListener(this);
            popupMenu_SelectAll.addActionListener(this);
    
            // 文本编辑区注册右键菜单事件
            editArea.addMouseListener(new MouseAdapter() {
                public void mousePressed(MouseEvent e) {
                    if (e.isPopupTrigger())// 返回此鼠标事件是否为该平台的弹出菜单触发事件
                    {
                        popupMenu.show(e.getComponent(), e.getX(), e.getY());// 在组件调用者的坐标空间中的位置
                                                                                // X、Y
                                                                                // 显示弹出菜单
                    }
                    checkMenuItemEnabled();// 设置剪切，复制，粘帖，删除等功能的可用性
                    editArea.requestFocus();// 编辑区获取焦点
                }
    
                public void mouseReleased(MouseEvent e) {
                    if (e.isPopupTrigger())// 返回此鼠标事件是否为该平台的弹出菜单触发事件
                    {
                        popupMenu.show(e.getComponent(), e.getX(), e.getY());// 在组件调用者的坐标空间中的位置
                                                                                // X、Y
                                                                                // 显示弹出菜单
                    }
                    checkMenuItemEnabled();// 设置剪切，复制，粘帖，删除等功能的可用性
                    editArea.requestFocus();// 编辑区获取焦点
                }
            });// 文本编辑区注册右键菜单事件结束
    
            // 创建和添加状态栏
            statusLabel = new JLabel("　按F1获取帮助");
            this.add(statusLabel, BorderLayout.SOUTH);// 向窗口添加状态栏标签
    
            // 设置窗口在屏幕上的位置、大小和可见性
            this.setLocation(100, 100);
            this.setSize(650, 550);
            this.setVisible(true);
            // 添加窗口监听器
            addWindowListener(new WindowAdapter() {
                public void windowClosing(WindowEvent e) {
                    exitWindowChoose();
                }
            });
    
            checkMenuItemEnabled();
            editArea.requestFocus();
        }// 构造函数Notepad结束
    
        // 设置菜单项的可用性：剪切，复制，粘帖，删除功能
        public void checkMenuItemEnabled() {
            String selectText = editArea.getSelectedText();
            if (selectText == null) {
                editMenu_Cut.setEnabled(false);
                popupMenu_Cut.setEnabled(false);
                editMenu_Copy.setEnabled(false);
                popupMenu_Copy.setEnabled(false);
                editMenu_Delete.setEnabled(false);
                popupMenu_Delete.setEnabled(false);
            } else {
                editMenu_Cut.setEnabled(true);
                popupMenu_Cut.setEnabled(true);
                editMenu_Copy.setEnabled(true);
                popupMenu_Copy.setEnabled(true);
                editMenu_Delete.setEnabled(true);
                popupMenu_Delete.setEnabled(true);
            }
            // 粘帖功能可用性判断
            Transferable contents = clipBoard.getContents(this);
            if (contents == null) {
                editMenu_Paste.setEnabled(false);
                popupMenu_Paste.setEnabled(false);
            } else {
                editMenu_Paste.setEnabled(true);
                popupMenu_Paste.setEnabled(true);
            }
        }// 方法checkMenuItemEnabled()结束
    
        // 关闭窗口时调用
        public void exitWindowChoose() {
            editArea.requestFocus();
            String currentValue = editArea.getText();
            if (currentValue.equals(oldValue) == true) {
                System.exit(0);
            } else {
                int exitChoose = JOptionPane.showConfirmDialog(this,
                        "您的文件尚未保存，是否保存？", "退出提示", JOptionPane.YES_NO_CANCEL_OPTION);
                if (exitChoose == JOptionPane.YES_OPTION) { // boolean isSave=false;
                    if (isNewFile) {
                        String str = null;
                        JFileChooser fileChooser = new JFileChooser();
                        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                        fileChooser.setApproveButtonText("确定");
                        fileChooser.setDialogTitle("另存为");
    
                        int result = fileChooser.showSaveDialog(this);
    
                        if (result == JFileChooser.CANCEL_OPTION) {
                            statusLabel.setText("　您没有保存文件");
                            return;
                        }
    
                        File saveFileName = fileChooser.getSelectedFile();
    
                        if (saveFileName == null
                                || saveFileName.getName().equals("")) {
                            JOptionPane.showMessageDialog(this, "不合法的文件名",
                                    "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                        } else {
                            try {
                                FileWriter fw = new FileWriter(saveFileName);
                                BufferedWriter bfw = new BufferedWriter(fw);
                                bfw.write(editArea.getText(), 0, editArea.getText()
                                        .length());
                                bfw.flush();
                                fw.close();
    
                                isNewFile = false;
                                currentFile = saveFileName;
                                oldValue = editArea.getText();
    
                                this.setTitle(saveFileName.getName() + "  - 记事本");
                                statusLabel.setText("　当前打开文件:"
                                        + saveFileName.getAbsoluteFile());
                                // isSave=true;
                            } catch (IOException ioException) {
                            }
                        }
                    } else {
                        try {
                            FileWriter fw = new FileWriter(currentFile);
                            BufferedWriter bfw = new BufferedWriter(fw);
                            bfw.write(editArea.getText(), 0, editArea.getText()
                                    .length());
                            bfw.flush();
                            fw.close();
                            // isSave=true;
                        } catch (IOException ioException) {
                        }
                    }
                    System.exit(0);
                    // if(isSave)System.exit(0);
                    // else return;
                } else if (exitChoose == JOptionPane.NO_OPTION) {
                    System.exit(0);
                } else {
                    return;
                }
            }
        }// 关闭窗口时调用方法结束
    
        
        // "字体"方法
        public void font() {
            final JDialog fontDialog = new JDialog(this, "字体设置", false);
            Container con = fontDialog.getContentPane();
            con.setLayout(new FlowLayout(FlowLayout.LEFT));
            JLabel fontLabel = new JLabel("字体(F)：");
            fontLabel.setPreferredSize(new Dimension(100, 20));// 构造一个Dimension，并将其初始化为指定宽度和高度
            JLabel styleLabel = new JLabel("字形(Y)：");
            styleLabel.setPreferredSize(new Dimension(100, 20));
            JLabel sizeLabel = new JLabel("大小(S)：");
            sizeLabel.setPreferredSize(new Dimension(100, 20));
            final JLabel sample = new JLabel("张选仲的记事本-ZXZ's Notepad");
            // sample.setHorizontalAlignment(SwingConstants.CENTER);
            final JTextField fontText = new JTextField(9);
            fontText.setPreferredSize(new Dimension(200, 20));
            final JTextField styleText = new JTextField(8);
            styleText.setPreferredSize(new Dimension(200, 20));
            final int style[] = { Font.PLAIN, Font.BOLD, Font.ITALIC,
                    Font.BOLD + Font.ITALIC };
            final JTextField sizeText = new JTextField(5);
            sizeText.setPreferredSize(new Dimension(200, 20));
            JButton okButton = new JButton("确定");
            JButton cancel = new JButton("取消");
            cancel.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    fontDialog.dispose();
                }
            });
            Font currentFont = editArea.getFont();
            fontText.setText(currentFont.getFontName());
            fontText.selectAll();
            // styleText.setText(currentFont.getStyle());
            // styleText.selectAll();
            if (currentFont.getStyle() == Font.PLAIN)
                styleText.setText("常规");
            else if (currentFont.getStyle() == Font.BOLD)
                styleText.setText("粗体");
            else if (currentFont.getStyle() == Font.ITALIC)
                styleText.setText("斜体");
            else if (currentFont.getStyle() == (Font.BOLD + Font.ITALIC))
                styleText.setText("粗斜体");
            styleText.selectAll();
            String str = String.valueOf(currentFont.getSize());
            sizeText.setText(str);
            sizeText.selectAll();
            final JList fontList, styleList, sizeList;
            GraphicsEnvironment ge = GraphicsEnvironment
                    .getLocalGraphicsEnvironment();
            final String fontName[] = ge.getAvailableFontFamilyNames();
            fontList = new JList(fontName);
            fontList.setFixedCellWidth(86);
            fontList.setFixedCellHeight(20);
            fontList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            final String fontStyle[] = { "常规", "粗体", "斜体", "粗斜体" };
            styleList = new JList(fontStyle);
            styleList.setFixedCellWidth(86);
            styleList.setFixedCellHeight(20);
            styleList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            if (currentFont.getStyle() == Font.PLAIN)
                styleList.setSelectedIndex(0);
            else if (currentFont.getStyle() == Font.BOLD)
                styleList.setSelectedIndex(1);
            else if (currentFont.getStyle() == Font.ITALIC)
                styleList.setSelectedIndex(2);
            else if (currentFont.getStyle() == (Font.BOLD + Font.ITALIC))
                styleList.setSelectedIndex(3);
            final String fontSize[] = { "8", "9", "10", "11", "12", "14", "16",
                    "18", "20", "22", "24", "26", "28", "36", "48", "72" };
            sizeList = new JList(fontSize);
            sizeList.setFixedCellWidth(43);
            sizeList.setFixedCellHeight(20);
            sizeList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
            fontList.addListSelectionListener(new ListSelectionListener() {
                public void valueChanged(ListSelectionEvent event) {
                    fontText.setText(fontName[fontList.getSelectedIndex()]);
                    fontText.selectAll();
                    Font sampleFont1 = new Font(fontText.getText(), style[styleList
                            .getSelectedIndex()], Integer.parseInt(sizeText
                            .getText()));
                    sample.setFont(sampleFont1);
                }
            });
            styleList.addListSelectionListener(new ListSelectionListener() {
                public void valueChanged(ListSelectionEvent event) {
                    int s = style[styleList.getSelectedIndex()];
                    styleText.setText(fontStyle[s]);
                    styleText.selectAll();
                    Font sampleFont2 = new Font(fontText.getText(), style[styleList
                            .getSelectedIndex()], Integer.parseInt(sizeText
                            .getText()));
                    sample.setFont(sampleFont2);
                }
            });
            sizeList.addListSelectionListener(new ListSelectionListener() {
                public void valueChanged(ListSelectionEvent event) {
                    sizeText.setText(fontSize[sizeList.getSelectedIndex()]);
                    // sizeText.requestFocus();
                    sizeText.selectAll();
                    Font sampleFont3 = new Font(fontText.getText(), style[styleList
                            .getSelectedIndex()], Integer.parseInt(sizeText
                            .getText()));
                    sample.setFont(sampleFont3);
                }
            });
            okButton.addActionListener(new ActionListener() {
                public void actionPerformed(ActionEvent e) {
                    Font okFont = new Font(fontText.getText(), style[styleList
                            .getSelectedIndex()], Integer.parseInt(sizeText
                            .getText()));
                    editArea.setFont(okFont);
                    fontDialog.dispose();
                }
            });
            JPanel samplePanel = new JPanel();
            samplePanel.setBorder(BorderFactory.createTitledBorder("示例"));
            // samplePanel.setLayout(new FlowLayout(FlowLayout.CENTER));
            samplePanel.add(sample);
            JPanel panel1 = new JPanel();
            JPanel panel2 = new JPanel();
            JPanel panel3 = new JPanel();
            // JPanel panel4=new JPanel();
            // JPanel panel5=new JPanel();
            // panel1.add(fontLabel);
            // panel1.add(styleLabel);
            // panel1.add(sizeLabel);
            // panel2.add(fontText);
            // panel2.add(new
            // JScrollPane(fontList));//JList不支持直接滚动，所以要让JList作为JScrollPane的视口视图
            // panel2.setLayout(new GridLayout(2,1));
            // panel3.add(styleText);
            // panel3.add(new JScrollPane(styleList));
            // panel3.setLayout(new GridLayout(2,1));
            // panel4.add(sizeText);
            // panel4.add(new JScrollPane(sizeText));
            // panel4.setLayout(new GridLayout(2,1));
            // panel5.add(okButton);
            // panel5.add(cancel);
            // con.add(panel1);
            // con.add(panel2);
            // con.add(panel3);
            // con.add(panel4);
            // con.add(panel5);
            panel2.add(fontText);
            panel2.add(styleText);
            panel2.add(sizeText);
            panel2.add(okButton);
            panel3.add(new JScrollPane(fontList));// JList不支持直接滚动，所以要让JList作为JScrollPane的视口视图
            panel3.add(new JScrollPane(styleList));
            panel3.add(new JScrollPane(sizeList));
            panel3.add(cancel);
            con.add(panel1);
            con.add(panel2);
            con.add(panel3);
            con.add(samplePanel);
            fontDialog.setSize(350, 340);
            fontDialog.setLocation(200, 200);
            fontDialog.setResizable(false);
            fontDialog.setVisible(true);
        }
    
        // public void menuPerformed(MenuEvent e)
        // { checkMenuItemEnabled();//设置剪切、复制、粘贴、删除等功能的可用性
        // }
    
        public void actionPerformed(ActionEvent e) { // 新建
            if (e.getSource() == fileMenu_New) {
                editArea.requestFocus();
                String currentValue = editArea.getText();
                boolean isTextChange = (currentValue.equals(oldValue)) ? false
                        : true;
                if (isTextChange) {
                    int saveChoose = JOptionPane.showConfirmDialog(this,
                            "您的文件尚未保存，是否保存？", "提示",
                            JOptionPane.YES_NO_CANCEL_OPTION);
                    if (saveChoose == JOptionPane.YES_OPTION) {
                        String str = null;
                        JFileChooser fileChooser = new JFileChooser();
                        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                        // fileChooser.setApproveButtonText("确定");
                        fileChooser.setDialogTitle("另存为");
                        int result = fileChooser.showSaveDialog(this);
                        if (result == JFileChooser.CANCEL_OPTION) {
                            statusLabel.setText("您没有选择任何文件");
                            return;
                        }
                        File saveFileName = fileChooser.getSelectedFile();
                        if (saveFileName == null
                                || saveFileName.getName().equals("")) {
                            JOptionPane.showMessageDialog(this, "不合法的文件名",
                                    "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                        } else {
                            try {
                                FileWriter fw = new FileWriter(saveFileName);
                                BufferedWriter bfw = new BufferedWriter(fw);
                                bfw.write(editArea.getText(), 0, editArea.getText()
                                        .length());
                                bfw.flush();// 刷新该流的缓冲
                                bfw.close();
                                isNewFile = false;
                                currentFile = saveFileName;
                                oldValue = editArea.getText();
                                this.setTitle(saveFileName.getName() + " - 记事本");
                                statusLabel.setText("当前打开文件："
                                        + saveFileName.getAbsoluteFile());
                            } catch (IOException ioException) {
                            }
                        }
                    } else if (saveChoose == JOptionPane.NO_OPTION) {
                        editArea.replaceRange("", 0, editArea.getText().length());
                        statusLabel.setText(" 新建文件");
                        this.setTitle("无标题 - 记事本");
                        isNewFile = true;
                        undo.discardAllEdits(); // 撤消所有的"撤消"操作
                        editMenu_Undo.setEnabled(false);
                        oldValue = editArea.getText();
                    } else if (saveChoose == JOptionPane.CANCEL_OPTION) {
                        return;
                    }
                } else {
                    editArea.replaceRange("", 0, editArea.getText().length());
                    statusLabel.setText(" 新建文件");
                    this.setTitle("无标题 - 记事本");
                    isNewFile = true;
                    undo.discardAllEdits();// 撤消所有的"撤消"操作
                    editMenu_Undo.setEnabled(false);
                    oldValue = editArea.getText();
                }
            }// 新建结束
                // 打开
            else if (e.getSource() == fileMenu_Open) {
                editArea.requestFocus();
                String currentValue = editArea.getText();
                boolean isTextChange = (currentValue.equals(oldValue)) ? false
                        : true;
                if (isTextChange) {
                    int saveChoose = JOptionPane.showConfirmDialog(this,
                            "您的文件尚未保存，是否保存？", "提示",
                            JOptionPane.YES_NO_CANCEL_OPTION);
                    if (saveChoose == JOptionPane.YES_OPTION) {
                        String str = null;
                        JFileChooser fileChooser = new JFileChooser();
                        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                        // fileChooser.setApproveButtonText("确定");
                        fileChooser.setDialogTitle("另存为");
                        int result = fileChooser.showSaveDialog(this);
                        if (result == JFileChooser.CANCEL_OPTION) {
                            statusLabel.setText("您没有选择任何文件");
                            return;
                        }
                        File saveFileName = fileChooser.getSelectedFile();
                        if (saveFileName == null
                                || saveFileName.getName().equals("")) {
                            JOptionPane.showMessageDialog(this, "不合法的文件名",
                                    "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                        } else {
                            try {
                                FileWriter fw = new FileWriter(saveFileName);
                                BufferedWriter bfw = new BufferedWriter(fw);
                                bfw.write(editArea.getText(), 0, editArea.getText()
                                        .length());
                                bfw.flush();// 刷新该流的缓冲
                                bfw.close();
                                isNewFile = false;
                                currentFile = saveFileName;
                                oldValue = editArea.getText();
                                this.setTitle(saveFileName.getName() + " - 记事本");
                                statusLabel.setText("当前打开文件："
                                        + saveFileName.getAbsoluteFile());
                            } catch (IOException ioException) {
                            }
                        }
                    } else if (saveChoose == JOptionPane.NO_OPTION) {
                        String str = null;
                        JFileChooser fileChooser = new JFileChooser();
                        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                        // fileChooser.setApproveButtonText("确定");
                        fileChooser.setDialogTitle("打开文件");
                        int result = fileChooser.showOpenDialog(this);
                        if (result == JFileChooser.CANCEL_OPTION) {
                            statusLabel.setText("您没有选择任何文件");
                            return;
                        }
                        File fileName = fileChooser.getSelectedFile();
                        if (fileName == null || fileName.getName().equals("")) {
                            JOptionPane.showMessageDialog(this, "不合法的文件名",
                                    "不合法的文件名", JOptionPane.ERROR_MESSAGE);
                        } else {
                            try {
                                FileReader fr = new FileReader(fileName);
                                BufferedReader bfr = new BufferedReader(fr);
                                editArea.setText("");
                                while ((str = bfr.readLine()) != null) {
                                    editArea.append(str);
                                }
                                this.setTitle(fileName.getName() + " - 记事本");
                                statusLabel.setText(" 当前打开文件："
                                        + fileName.getAbsoluteFile());
                                fr.close();
                                isNewFile = false;
                                currentFile = fileName;
                                oldValue = editArea.getText();
                            } catch (IOException ioException) {
                            }
                        }
                    } else {
                        return;
                    }
                } else {
                    String str = null;
                    JFileChooser fileChooser = new JFileChooser();
                    fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                    // fileChooser.setApproveButtonText("确定");
                    fileChooser.setDialogTitle("打开文件");
                    int result = fileChooser.showOpenDialog(this);
                    if (result == JFileChooser.CANCEL_OPTION) {
                        statusLabel.setText(" 您没有选择任何文件 ");
                        return;
                    }
                    File fileName = fileChooser.getSelectedFile();
                    if (fileName == null || fileName.getName().equals("")) {
                        JOptionPane.showMessageDialog(this, "不合法的文件名", "不合法的文件名",
                                JOptionPane.ERROR_MESSAGE);
                    } else {
                        try {
                            FileReader fr = new FileReader(fileName);
                            BufferedReader bfr = new BufferedReader(fr);
                            editArea.setText("");
                            while ((str = bfr.readLine()) != null) {
                                editArea.append(str);
                            }
                            this.setTitle(fileName.getName() + " - 记事本");
                            statusLabel.setText(" 当前打开文件："
                                    + fileName.getAbsoluteFile());
                            fr.close();
                            isNewFile = false;
                            currentFile = fileName;
                            oldValue = editArea.getText();
                        } catch (IOException ioException) {
                        }
                    }
                }
            }// 打开结束
                // 保存
            else if (e.getSource() == fileMenu_Save) {
                editArea.requestFocus();
                if (isNewFile) {
                    String str = null;
                    JFileChooser fileChooser = new JFileChooser();
                    fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                    // fileChooser.setApproveButtonText("确定");
                    fileChooser.setDialogTitle("保存");
                    int result = fileChooser.showSaveDialog(this);
                    if (result == JFileChooser.CANCEL_OPTION) {
                        statusLabel.setText("您没有选择任何文件");
                        return;
                    }
                    File saveFileName = fileChooser.getSelectedFile();
                    if (saveFileName == null || saveFileName.getName().equals("")) {
                        JOptionPane.showMessageDialog(this, "不合法的文件名", "不合法的文件名",
                                JOptionPane.ERROR_MESSAGE);
                    } else {
                        try {
                            FileWriter fw = new FileWriter(saveFileName);
                            BufferedWriter bfw = new BufferedWriter(fw);
                            bfw.write(editArea.getText(), 0, editArea.getText()
                                    .length());
                            bfw.flush();// 刷新该流的缓冲
                            bfw.close();
                            isNewFile = false;
                            currentFile = saveFileName;
                            oldValue = editArea.getText();
                            this.setTitle(saveFileName.getName() + " - 记事本");
                            statusLabel.setText("当前打开文件："
                                    + saveFileName.getAbsoluteFile());
                        } catch (IOException ioException) {
                        }
                    }
                } else {
                    try {
                        FileWriter fw = new FileWriter(currentFile);
                        BufferedWriter bfw = new BufferedWriter(fw);
                        bfw.write(editArea.getText(), 0, editArea.getText()
                                .length());
                        bfw.flush();
                        fw.close();
                    } catch (IOException ioException) {
                    }
                }
            }// 保存结束
                // 另存为
            else if (e.getSource() == fileMenu_SaveAs) {
                editArea.requestFocus();
                String str = null;
                JFileChooser fileChooser = new JFileChooser();
                fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
                // fileChooser.setApproveButtonText("确定");
                fileChooser.setDialogTitle("另存为");
                int result = fileChooser.showSaveDialog(this);
                if (result == JFileChooser.CANCEL_OPTION) {
                    statusLabel.setText("　您没有选择任何文件");
                    return;
                }
                File saveFileName = fileChooser.getSelectedFile();
                if (saveFileName == null || saveFileName.getName().equals("")) {
                    JOptionPane.showMessageDialog(this, "不合法的文件名", "不合法的文件名",
                            JOptionPane.ERROR_MESSAGE);
                } else {
                    try {
                        FileWriter fw = new FileWriter(saveFileName);
                        BufferedWriter bfw = new BufferedWriter(fw);
                        bfw.write(editArea.getText(), 0, editArea.getText()
                                .length());
                        bfw.flush();
                        fw.close();
                        oldValue = editArea.getText();
                        this.setTitle(saveFileName.getName() + "  - 记事本");
                        statusLabel.setText("　当前打开文件:"
                                + saveFileName.getAbsoluteFile());
                    } catch (IOException ioException) {
                    }
                }
            }// 另存为结束
            
                // 退出
            else if (e.getSource() == fileMenu_Exit) {
                int exitChoose = JOptionPane.showConfirmDialog(this, "确定要退出吗?",
                        "退出提示", JOptionPane.OK_CANCEL_OPTION);
                if (exitChoose == JOptionPane.OK_OPTION) {
                    System.exit(0);
                } else {
                    return;
                }
            }
                // 编辑
                // else if(e.getSource()==editMenu)
                // { checkMenuItemEnabled();//设置剪切、复制、粘贴、删除等功能的可用性
                // }
                // 编辑结束
                // 撤销
            else if (e.getSource() == editMenu_Undo
                    || e.getSource() == popupMenu_Undo) {
                editArea.requestFocus();
                if (undo.canUndo()) {
                    try {
                        undo.undo();
                    } catch (CannotUndoException ex) {
                        System.out.println("Unable to undo:" + ex);
                        // ex.printStackTrace();
                    }
                }
                if (!undo.canUndo()) {
                    editMenu_Undo.setEnabled(false);
                }
            }// 撤销结束
                // 剪切
            else if (e.getSource() == editMenu_Cut
                    || e.getSource() == popupMenu_Cut) {
                editArea.requestFocus();
                String text = editArea.getSelectedText();
                StringSelection selection = new StringSelection(text);
                clipBoard.setContents(selection, null);
                editArea.replaceRange("", editArea.getSelectionStart(),
                        editArea.getSelectionEnd());
                checkMenuItemEnabled();// 设置剪切，复制，粘帖，删除功能的可用性
            }// 剪切结束
                // 复制
            else if (e.getSource() == editMenu_Copy
                    || e.getSource() == popupMenu_Copy) {
                editArea.requestFocus();
                String text = editArea.getSelectedText();
                StringSelection selection = new StringSelection(text);
                clipBoard.setContents(selection, null);
                checkMenuItemEnabled();// 设置剪切，复制，粘帖，删除功能的可用性
            }// 复制结束
                // 粘帖
            else if (e.getSource() == editMenu_Paste
                    || e.getSource() == popupMenu_Paste) {
                editArea.requestFocus();
                Transferable contents = clipBoard.getContents(this);
                if (contents == null)
                    return;
                String text = "";
                try {
                    text = (String) contents
                            .getTransferData(DataFlavor.stringFlavor);
                } catch (Exception exception) {
                }
                editArea.replaceRange(text, editArea.getSelectionStart(),
                        editArea.getSelectionEnd());
                checkMenuItemEnabled();
            }// 粘帖结束
                // 删除
            else if (e.getSource() == editMenu_Delete
                    || e.getSource() == popupMenu_Delete) {
                editArea.requestFocus();
                editArea.replaceRange("", editArea.getSelectionStart(),
                        editArea.getSelectionEnd());
                checkMenuItemEnabled(); // 设置剪切、复制、粘贴、删除等功能的可用性
            }// 删除结束
                // 查找
            else if (e.getSource() == editMenu_Find) {
                editArea.requestFocus();
                find();
            }// 查找结束
                // 查找下一个
            else if (e.getSource() == editMenu_FindNext) {
                editArea.requestFocus();
                find();
            }// 查找下一个结束
                // 替换
            else if (e.getSource() == editMenu_Replace) {
                editArea.requestFocus();
                replace();
            }// 替换结束
                // 转到
            else if (e.getSource() == editMenu_GoTo) {
                editArea.requestFocus();
                JOptionPane.showMessageDialog(this,
                        "对不起，此功能尚未实现！更多请看http://pan.muyi.so", "提示",
                        JOptionPane.WARNING_MESSAGE);
            }// 转到结束
                // 时间日期
            else if (e.getSource() == editMenu_TimeDate) {
                editArea.requestFocus();
                // SimpleDateFormat currentDateTime=new
                // SimpleDateFormat("HH:mmyyyy-MM-dd");
                // editArea.insert(currentDateTime.format(new
                // Date()),editArea.getCaretPosition());
                Calendar rightNow = Calendar.getInstance();
                Date date = rightNow.getTime();
                editArea.insert(date.toString(), editArea.getCaretPosition());
            }// 时间日期结束
                // 全选
            else if (e.getSource() == editMenu_SelectAll
                    || e.getSource() == popupMenu_SelectAll) {
                editArea.selectAll();
            }// 全选结束
                // 自动换行(已在前面设置)
            else if (e.getSource() == formatMenu_LineWrap) {
                if (formatMenu_LineWrap.getState())
                    editArea.setLineWrap(true);
                else
                    editArea.setLineWrap(false);
    
            }// 自动换行结束
                // 字体设置
            else if (e.getSource() == formatMenu_Font) {
                editArea.requestFocus();
                font();
            }// 字体设置结束
                // 设置状态栏可见性
            else if (e.getSource() == viewMenu_Status) {
                if (viewMenu_Status.getState())
                    statusLabel.setVisible(true);
                else
                    statusLabel.setVisible(false);
            }// 设置状态栏可见性结束
                // 帮助主题
            else if (e.getSource() == helpMenu_HelpTopics) {
                editArea.requestFocus();
                JOptionPane.showMessageDialog(this, "课程设计作业，感谢老师和同学的帮助！。", "相关帮助",
                        JOptionPane.INFORMATION_MESSAGE);
            }// 帮助主题结束
                // 关于
            else if (e.getSource() == helpMenu_AboutNotepad) {
                editArea.requestFocus();
                JOptionPane
                        .showMessageDialog(
                                this,
                                
                                         " 开发者：聂金龙 \n"
                                        + " 学号：201201030212\n"
                                        + " 专业：计算机科学与技术\n"
                                        ,
                                "记事本", JOptionPane.INFORMATION_MESSAGE);
            }// 关于结束
            
            //--------------字数统计
            
            else if (e.getSource() == tongjiMenu) {
                JOptionPane
                        .showMessageDialog(
                                this,
                                
                                         " 当前记事本字数:"+editArea.getText().length()
                                    
                                        ,
                                "字数", JOptionPane.INFORMATION_MESSAGE);
            }
            
            
            else if (e.getSource() == qianjinMenu) {
                editArea.requestFocus();
                Color color = JColorChooser.showDialog(this, "更改字体颜色", Color.black);
                if (color != null) {
                    editArea.setForeground(color);
                } else
                    return;
            }
            
            else if (e.getSource() == backgroudMenu) {
                editArea.requestFocus();
                Color color = JColorChooser.showDialog(this, "更改背景颜色", Color.white);
                if (color != null) {
                    editArea.setBackground(color);
                } else
                    return;
            }
            
        }// 方法actionPerformed()结束
    
        // 实现DocumentListener接口中的方法(与撤销操作有关)
        public void removeUpdate(DocumentEvent e) {
            editMenu_Undo.setEnabled(true);
        }
    
        public void insertUpdate(DocumentEvent e) {
            editMenu_Undo.setEnabled(true);
        }
    
        public void changedUpdate(DocumentEvent e) {
            editMenu_Undo.setEnabled(true);
        }// DocumentListener结束
    
        // 实现接口UndoableEditListener的类UndoHandler(与撤销操作有关)
        class UndoHandler implements UndoableEditListener {
            public void undoableEditHappened(UndoableEditEvent uee) {
                undo.addEdit(uee.getEdit());
            }
        }
    
        // main函数开始
        public static void main(String args[]) {
            Notepad notepad = new Notepad();
            notepad.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);// 使用 System exit
                                                                    // 方法退出应用程序
        }// main函数结束
    }

[32ff1218b713d6920b9df1f387a7d4cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/323aa02f6165485f8ccbd4d27a49a75a.png
[3f0e9ebc376cb978ed4a4f9a5f1aab92.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/36a60367fdac48a694216bf72eca30c4.png
[679732e0edf0d8bdfa67be89817ac174.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/8459e579f3c446158399b570ebf6979c.png
[0aa0fb80dd195a604123c9975e3b04fb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/999a4f525c6c4c66851fa8ad72b7f097.png
[71ac33f393246018773329a5a91bc4f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/60d010a34cad476aa5d1ab5f59ac1d86.png