java记事本源代码

本文仿电脑自带记事本，实现的功能有新建、新窗口、打开、保存、另存为、退出、撤销、剪切、复制、粘贴、删除、查找、查找下一个、查找上一个、替换、转到、全选、时间/日期、自动换行、缩放（放大、缩小、恢复默认大小），未实现功能有页面设置、打印、字体、状态栏、帮助。

仅供学习、参考，不要照搬，搬了弄懂也行，如有问题可以评论提出。

各部分内容的实现我自己的见解如下，有不足之处欢迎指正：

JAVA记事本界面实现_云边守望者的博客-CSDN博客

java记事本实现查找功能_云边守望者的博客-CSDN博客

java记事本实现替换功能_云边守望者的博客-CSDN博客

java记事本新窗口、全选、时间/日期、自动换行、缩放的实现_云边守望者的博客-CSDN博客

java记事本实现剪切、复制、粘贴、删除_云边守望者的博客-CSDN博客

java记事本实现新建、打开、保存、另存为、退出功能_云边守望者的博客-CSDN博客

java记事本实现转到和撤销功能_云边守望者的博客-CSDN博客

附上几张最终实现的界面图：

另一种风格：

源码：

import java.awt.BorderLayout;//边框布局管理器
import java.awt.Dimension;//构件属性
import java.awt.Toolkit;//工具箱
import java.awt.Container;//容器 window panel
import java.awt.FlowLayout;//流式布局管理器
import java.awt.datatransfer.Clipboard;//获取系统剪贴板
import java.awt.datatransfer.Transferable;//数据封装
import java.awt.datatransfer.StringSelection;//创建能传输指定String的Transferable
import java.awt.datatransfer.DataFlavor;//Transferable支持的数据风格
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;//事件监听
import java.awt.event.WindowAdapter;//针对窗口事件
import java.awt.event.WindowEvent;
import java.awt.event.KeyEvent;
import java.awt.GridLayout;//网格布局
import java.io.BufferedReader;//缓冲区读入字符流
import java.io.BufferedWriter;//字符流写入缓冲区
import java.io.File;
import java.io.FileNotFoundException;//找不到指定文件异常
import java.io.FileOutputStream;//文件字节输出流
import java.io.FileReader;//文件读取
import java.io.IOException;
import java.io.OutputStreamWriter;//字符->字节
import javax.swing.ImageIcon;//添加图像图标
import javax.swing.JFileChooser;//文件选择器
import javax.swing.JFrame;//窗体
import javax.swing.JMenu;//菜单
import javax.swing.JMenuBar;//菜单栏
import javax.swing.JMenuItem;//菜单中的项
import javax.swing.JLabel;
import javax.swing.JTextField;//允许编辑单行文本的组件
import javax.swing.JButton;
import javax.swing.JCheckBox;//复选框
import javax.swing.JCheckBoxMenuItem;
import javax.swing.ButtonGroup;//搭配Radiobutton
import javax.swing.JRadioButton;//单选按钮
import javax.swing.BorderFactory;
import javax.swing.JOptionPane;//对话框
import javax.swing.JScrollPane;//滚动面板
import javax.swing.JTextArea;//文本区域组件
import javax.swing.KeyStroke;//快捷键
import javax.swing.event.MenuListener;//菜单监听
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;//接受文本文档更改通知的接口
import javax.swing.event.UndoableEditEvent;
import javax.swing.event.UndoableEditListener;//所有可撤销编辑监听器
import javax.swing.event.MenuEvent;
import javax.swing.JPanel;//面板
import javax.swing.JDialog;//对话框
import javax.swing.undo.UndoManager;//撤销管理器
import java.text.SimpleDateFormat;
import java.util.Date;
import java.awt.Rectangle;
import javax.swing.text.BadLocationException;
import java.awt.Font;
import javax.swing.UIManager;


public class MyNotepad extends JFrame implements DocumentListener{    
    MenuHandler menuhandler = new MenuHandler();//事件处理
    ImageIcon image;//窗口图标
    JMenuBar jmenu;//菜单栏
    JMenu jm_file,jm_edit,jm_format,jm_look,jm_help;
    //文件的菜单项  
    JMenuItem file_newfile,file_newwindow,file_open,file_save,file_saveas,file_design,file_print,file_exit;
    //编辑的菜单项  
    JMenuItem edit_undo,edit_cut,edit_copy,edit_paste,edit_delete,edit_find,edit_findnext,edit_findpre,edit_replace,edit_goto,edit_all,edit_time;
    //格式的菜单项
    JCheckBoxMenuItem format_linewrap;
    JMenuItem format_font;
    //查看的菜单项
    JMenu look_zoom;
    JMenuItem look_status;
    //缩放的菜单项
    JMenuItem increase,reduce,source;
    //帮助的菜单项
    JMenuItem help_item1,help_item2,help_item3;
    JTextArea jtext;//文本区域
    JScrollPane jspane;//滚动面板
    private static String name;
    JFileChooser jfilechoose = new JFileChooser("C:\\Users\\abc\\Desktop\\java_design");//文件选择器(打开地址)
    String filepath=null;
    //系统剪贴板  
    Toolkit toolkit=Toolkit.getDefaultToolkit();  
    Clipboard clipBoard=toolkit.getSystemClipboard();
    UndoManager undom;//撤销管理器
    //查找窗口组件
    JDialog findDialog;//查找窗体
    JTextField findText;//查找文本
    JCheckBox matchCheckBox;//区分大小写复选框
    JRadioButton upButton;//向上按钮
    JRadioButton downButton;//向下按钮

    //替换窗口组件
    JDialog replaceDialog;
    JTextField findText1;
    JCheckBox matchCheckBox1;
    JRadioButton upButton1;
    JRadioButton downButton1;
    JTextField replaceText;//替换文本

    //转到窗口组件
    JDialog gotoDialog;
    JTextField field;

    public static void main(String[] args) {
        // try{
        //     UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
        // }catch(Exception e){
        //     e.printStackTrace();
        // }//添加后可改变文件选择器的风格
        new MyNotepad().init();
    }
 
     // 初始化界面
    public void init() {
        // setSize(800, 600);
        /*窗口显示位置 x,y,width,height*/
        setBounds(150,150,800,600);
        // 设置关闭按钮动作不执行任何操作
        setDefaultCloseOperation(0);
        //指定布局管理器为BorderLayout
        setLayout(new BorderLayout());
        name = "新建文本文档.txt";
        // 设置标志图案
        image = new ImageIcon("C:\\Users\\abc\\Desktop\\miao.jpg");
        setIconImage(image.getImage());
        // 设置文件名
        setTitle(name + " - 记事本");
        // 添加菜单栏
        addMenu();
        // 添加文本域
        jtext = new JTextArea();
        jtext.setFont(new Font("宋体", Font.PLAIN, 14));// 设置字体样式
        jtext.setWrapStyleWord(true);//设置单词在一行不足容纳时换行   
        jtext.setTabSize(2);//Tab键在文本框中的移动距离
        undom = new UndoManager();// 创建撤销管理器
        UndoableEditListener undoHandler=new UndoHandler();
        jtext.getDocument().addUndoableEditListener(undoHandler);// 为文本注册监听器  
        jtext.getDocument().addDocumentListener(MyNotepad.this);
        // 添加滚动面板
        jspane = new JScrollPane(jtext);
        jspane.setPreferredSize(new Dimension(600, 550));
        add(jspane, BorderLayout.CENTER);
        setResizable(true);//可改变大小
        setVisible(true);// 设置窗口可见
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                int select = showSaveDialog();
                if (select != JOptionPane.CANCEL_OPTION && select != JOptionPane.CLOSED_OPTION)
                    setDefaultCloseOperation(2);//隐藏并释放窗体，dispose()，当最后一个窗口被释放后，则程序也随之运行结束。 
            }
        });
    }
    // 添加菜单栏
    private void addMenu() {
        // 添加菜单栏
        jmenu = new JMenuBar();
        // 设置菜单栏位置在顶级窗口的顶部
        setJMenuBar(jmenu);
        // 菜单栏菜单
        jm_file = new JMenu("文件(F)");
        jm_file.setMnemonic('F');
        // 给文件菜单添加菜单项
        file_newfile = new JMenuItem("新建(N)");
        file_newfile.setActionCommand("newfile");
        file_newfile.addActionListener(menuhandler);
        file_newfile.setAccelerator(KeyStroke.getKeyStroke("ctrl N"));

        file_newwindow = new JMenuItem("新窗口(W)");
        file_newwindow.setActionCommand("newwindow");
        file_newwindow.addActionListener(menuhandler);
        file_newwindow.setAccelerator(KeyStroke.getKeyStroke("ctrl shift N"));

        file_open = new JMenuItem("打开(O)");
        file_open.setActionCommand("open");
        file_open.addActionListener(menuhandler);
        file_open.setAccelerator(KeyStroke.getKeyStroke("ctrl O"));

        file_save = new JMenuItem("保存(S)");
        file_save.setActionCommand("save");
        file_save.addActionListener(menuhandler);
        file_save.setAccelerator(KeyStroke.getKeyStroke("ctrl S"));

        file_saveas = new JMenuItem("另存为(A)");
        file_saveas.setActionCommand("saveas");
        file_saveas.addActionListener(menuhandler);
        file_saveas.setAccelerator(KeyStroke.getKeyStroke("ctrl shift S"));

        file_design = new JMenuItem("页面设置(U)");

        file_print = new JMenuItem("打印(P)");
        file_print.setAccelerator(KeyStroke.getKeyStroke("ctrl P"));

        file_exit = new JMenuItem("退出(X)");
        file_exit.setActionCommand("exit");
        file_exit.addActionListener(menuhandler);
        
        jm_edit = new JMenu("编辑(E)");
        jm_edit.setMnemonic('E');
        //给编辑菜单添加菜单项
         edit_undo = new JMenuItem("撤销(U)");
         edit_undo.setActionCommand("undo");
        edit_undo.addActionListener(menuhandler);
        edit_undo.setAccelerator(KeyStroke.getKeyStroke("ctrl Z"));
        edit_undo.setEnabled(false); 

        edit_cut = new JMenuItem("剪切(T)");
        edit_cut.setActionCommand("cut");
        edit_cut.addActionListener(menuhandler);
        edit_cut.setAccelerator(KeyStroke.getKeyStroke("ctrl X"));

        edit_copy = new JMenuItem("复制(C)");
        edit_copy.setActionCommand("copy");
        edit_copy.addActionListener(menuhandler);
        edit_copy.setAccelerator(KeyStroke.getKeyStroke("ctrl C"));

        edit_paste = new JMenuItem("粘贴(P)");
        edit_paste.setActionCommand("stickup");
        edit_paste.addActionListener(menuhandler);
        edit_paste.setAccelerator(KeyStroke.getKeyStroke("ctrl V"));

        edit_delete = new JMenuItem("删除(L)");
        edit_delete.setActionCommand("delete");
        edit_delete.addActionListener(menuhandler);
        edit_delete.setAccelerator(KeyStroke.getKeyStroke("DELETE"));

        edit_find = new JMenuItem("查找(F)");
        edit_find.setActionCommand("findwindow");
        edit_find.addActionListener(menuhandler);
        edit_find.setAccelerator(KeyStroke.getKeyStroke("ctrl F"));

        edit_findnext = new JMenuItem("查找下一个(N)");
        edit_findnext.setActionCommand("fastfindnext");
        edit_findnext.addActionListener(menuhandler);
        edit_findnext.setAccelerator(KeyStroke.getKeyStroke("F3"));

        edit_findpre = new JMenuItem("查找上一个(V)");
        edit_findpre.setActionCommand("fastfindpre");
        edit_findpre.addActionListener(menuhandler);
        edit_findpre.setAccelerator(KeyStroke.getKeyStroke("shift F3"));

        edit_replace = new JMenuItem("替换(R)");
        edit_replace.setActionCommand("replacewindow");
        edit_replace.addActionListener(menuhandler);
        edit_replace.setAccelerator(KeyStroke.getKeyStroke("ctrl H"));

        edit_goto = new JMenuItem("转到(G)");
        edit_goto.setActionCommand("gotowindow");
        edit_goto.addActionListener(menuhandler);
        edit_goto.setAccelerator(KeyStroke.getKeyStroke("ctrl G"));

        edit_all = new JMenuItem("全选(A)");
        edit_all.setActionCommand("selectall");
        edit_all.addActionListener(menuhandler);
        edit_all.setAccelerator(KeyStroke.getKeyStroke("ctrl A"));

        edit_time = new JMenuItem("时间/日期(D)");
        edit_time.setActionCommand("time");
        edit_time.addActionListener(menuhandler);
        edit_time.setAccelerator(KeyStroke.getKeyStroke("F5"));
        //当选择编辑菜单时，设置剪切、复制、粘贴、删除等功能的可用性  
        jm_edit.addMenuListener(new MenuListener()  
        {   public void menuCanceled(MenuEvent e)//取消菜单时调用  
            {   checkMenuItemEnabled();//设置剪切、复制、粘贴、删除等功能的可用性  
            }  
            public void menuDeselected(MenuEvent e)//取消选择某个菜单时调用  
            {   checkMenuItemEnabled();//设置剪切、复制、粘贴、删除等功能的可用性  
            }  
            public void menuSelected(MenuEvent e)//选择某个菜单时调用  
            {   checkMenuItemEnabled();//设置剪切、复制、粘贴、删除等功能的可用性  
            }  
        }); 

        jm_format = new JMenu("格式(O)");
        jm_format.setMnemonic('O');
        // 给格式菜单添加菜单项
        format_linewrap = new JCheckBoxMenuItem("自动换行(W)");
        format_linewrap.setMnemonic('W');//设置快捷键ALT+W  
        format_linewrap.setState(false);//初始状态为不自动换行
        format_linewrap.setActionCommand("linewrap");
        format_linewrap.addActionListener(menuhandler); 
        format_font = new JMenuItem("字体(F)");

        jm_look = new JMenu("查看(V)");
        jm_look.setMnemonic('V');
        // 给查看菜单添加菜单项
        look_zoom = new JMenu("缩放(Z)");
        look_zoom.setMnemonic('Z');
        increase = new JMenuItem("放大(+)");
        increase.setActionCommand("sizetobig");
        increase.addActionListener(menuhandler);
        increase.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_EQUALS,KeyEvent.CTRL_MASK));

        reduce = new JMenuItem("缩小(-)");
        reduce.setActionCommand("sizetosmall");
        reduce.addActionListener(menuhandler);
        reduce.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_MINUS,KeyEvent.CTRL_MASK));

        source = new JMenuItem("恢复默认缩放");
        source.setActionCommand("sourcesize");
        source.addActionListener(menuhandler);
        source.setAccelerator(KeyStroke.getKeyStroke(KeyEvent.VK_0,KeyEvent.CTRL_MASK));
        look_status = new JMenuItem("状态栏(S)");

        jm_help = new JMenu("帮助(H)");
        jm_help.setMnemonic('H');
        // 给帮助菜单添加菜单项
        help_item1 = new JMenuItem("查看帮助(H)");
        help_item2 = new JMenuItem("发送反馈(F)");
        help_item3 = new JMenuItem("关于记事本(A)");

        jmenu.add(jm_file);
        jm_file.add(file_newfile);
        jm_file.add(file_newwindow);
        jm_file.add(file_open);
        jm_file.add(file_save);
        jm_file.add(file_saveas);
        jm_file.addSeparator();
        jm_file.add(file_design);
        jm_file.add(file_print);
        jm_file.addSeparator();
        jm_file.add(file_exit);

        jmenu.add(jm_edit);
        jm_edit.add(edit_undo);
        jm_file.addSeparator();
        jm_edit.add(edit_cut);
        jm_edit.add(edit_copy);
        jm_edit.add(edit_paste);
        jm_edit.add(edit_delete);
        jm_edit.addSeparator();
        jm_edit.add(edit_find);
        jm_edit.add(edit_findnext);
        jm_edit.add(edit_findpre);
        jm_edit.add(edit_replace);
        jm_edit.add(edit_goto);
        jm_edit.addSeparator();
        jm_edit.add(edit_all);
        jm_edit.add(edit_time);

        jmenu.add(jm_format);
        jm_format.add(format_linewrap);
        jm_format.add(format_font);

        jmenu.add(jm_look);
        jm_look.add(look_zoom);
        look_zoom.add(increase);
        look_zoom.add(reduce);
        look_zoom.add(source);
        jm_look.add(look_status);

        jmenu.add(jm_help);
        jm_help.add(help_item1);
        jm_help.add(help_item2);
        jm_help.addSeparator();
        jm_help.add(help_item3);
    }

    public void findwindow(){
        //查找窗口
        findDialog=new JDialog(this,"查找",false);//false时允许其他窗口同时处于激活状态
        Container con=findDialog.getContentPane();//获取对话框面板     
        con.setLayout(new FlowLayout(FlowLayout.LEFT)); //左对齐
        JLabel findContentLabel=new JLabel("查找内容(N)：");  
        findText=new JTextField(15);  
        JButton findNextButton=new JButton("查找下一个(F)：");
        findNextButton.setActionCommand("findnext");
        findNextButton.addActionListener(menuhandler);  
        matchCheckBox=new JCheckBox("区分大小写(C)");  
        ButtonGroup bGroup=new ButtonGroup();  
        upButton=new JRadioButton("向上(U)");  
        downButton=new JRadioButton("向下(U)");  
        downButton.setSelected(true);  
        bGroup.add(upButton);  
        bGroup.add(downButton);  
        /*ButtonGroup此类用于为一组按钮创建一个多斥（multiple-exclusion）作用域。 
        使用相同的 ButtonGroup 对象创建一组按钮意味着“开启”其中一个按钮时，将关闭组中的其他所有按钮。*/  
        /*JRadioButton此类实现一个单选按钮，此按钮项可被选择或取消选择，并可为用户显示其状态。 
        与 ButtonGroup 对象配合使用可创建一组按钮，一次只能选择其中的一个按钮。 
        （创建一个 ButtonGroup 对象并用其 add 方法将 JRadioButton 对象包含在此组中。）*/  
        JButton cancel=new JButton("取消");
        cancel.setActionCommand("findcancel");
        cancel.addActionListener(menuhandler);

        //创建查找对话框的界面  
        JPanel panel1=new JPanel();  
        JPanel panel2=new JPanel();  
        JPanel panel3=new JPanel();  
        JPanel directionPanel=new JPanel();  
        directionPanel.setBorder(BorderFactory.createTitledBorder("方向"));  
        //设置directionPanel组件的边框;  
        //BorderFactory.createTitledBorder(String title)创建一个新标题边框，使用默认边框（浮雕化）、默认文本位置（位于顶线上）、默认调整 (leading) 以及由当前外观确定的默认字体和文本颜色，并指定了标题文本。  
        directionPanel.add(upButton);  
        directionPanel.add(downButton);  
        panel1.setLayout(new GridLayout(2,1));  
        panel1.add(findNextButton);  
        panel1.add(cancel);  
        panel2.add(findContentLabel);  
        panel2.add(findText);  
        panel2.add(panel1);  
        panel3.add(matchCheckBox);  
        panel3.add(directionPanel);  
        con.add(panel2);  
        con.add(panel3);  
        findDialog.setSize(410,180);  
        findDialog.setResizable(false);//不可调整大小  
        findDialog.setLocation(230,280);  
        findDialog.setVisible(true);
    }
    public void replacewindow(){
        //替换窗口
        replaceDialog=new JDialog(this,"替换",false);//false时允许其他窗口同时处于激活状态(即无模式)  
        Container con=replaceDialog.getContentPane();//返回此对话框的contentPane对象  
        con.setLayout(new FlowLayout(FlowLayout.CENTER));  
        JLabel findContentLabel=new JLabel("查找内容(N)：");  
        findText1=new JTextField(15);  
        JButton findNextButton=new JButton("查找下一个(F):");
        findNextButton.setActionCommand("findnext1");
        findNextButton.addActionListener(menuhandler);
        JLabel replaceLabel=new JLabel("替换为(P)：");  
        replaceText=new JTextField(15);  
        JButton replaceButton=new JButton("替换(R)");
        replaceButton.setActionCommand("replace");
        replaceButton.addActionListener(menuhandler);
        JButton replaceAllButton=new JButton("全部替换(A)");
        replaceAllButton.setActionCommand("replaceall");
        replaceAllButton.addActionListener(menuhandler); 
        JButton cancel=new JButton("取消");
        cancel.setActionCommand("replacecancel");
        cancel.addActionListener(menuhandler);  
 
        matchCheckBox1=new JCheckBox("区分大小写(C)");  
        ButtonGroup bGroup=new ButtonGroup();  
        upButton1=new JRadioButton("向上(U)");  
        downButton1=new JRadioButton("向下(U)");  
        downButton1.setSelected(true);  
        bGroup.add(upButton1);  
        bGroup.add(downButton1);

        //创建替换对话框的界面  
        JPanel directionPanel=new JPanel();  
        directionPanel.setBorder(BorderFactory.createTitledBorder("方向"));  
        //设置directionPanel组件的边框;  
        //BorderFactory.createTitledBorder(String title)创建一个新标题边框，使用默认边框（浮雕化）、默认文本位置（位于顶线上）、默认调整 (leading) 以及由当前外观确定的默认字体和文本颜色，并指定了标题文本。  
        directionPanel.add(upButton1);  
        directionPanel.add(downButton1);  
        JPanel panel1=new JPanel();  
        JPanel panel2=new JPanel();  
        JPanel panel3=new JPanel();  
        JPanel panel4=new JPanel();  
        panel4.setLayout(new GridLayout(2,1));  
        panel1.add(findContentLabel);  
        panel1.add(findText1);  
        panel1.add(findNextButton);  
        panel4.add(replaceButton);  
        panel4.add(replaceAllButton);  
        panel2.add(replaceLabel);  
        panel2.add(replaceText);  
        panel2.add(panel4);  
        panel3.add(matchCheckBox1);  
        panel3.add(directionPanel);  
        panel3.add(cancel);  
        con.add(panel1);  
        con.add(panel2);  
        con.add(panel3);  
        replaceDialog.setSize(420,220);  
        replaceDialog.setResizable(false);//不可调整大小  
        replaceDialog.setLocation(230,280);  
        replaceDialog.setVisible(true); 
    }

    public void gotowindow(){
        //转到窗口
        gotoDialog = new JDialog(this,"转到指定行",false);
        Container con = gotoDialog.getContentPane();
        JButton gotobutton = new JButton("转到");
        gotobutton.setActionCommand("goto");
        gotobutton.addActionListener(menuhandler);
        JButton cancel = new JButton("取消");
        cancel.setActionCommand("gotocancel");
        cancel.addActionListener(menuhandler);
        gotoDialog.setLayout(null);
        
        JLabel linenumber = new JLabel("行号(L)：");
        field = new JTextField();
        linenumber.setBounds(10, 12, 400, 30);
        field.setBounds(10, 42, 350, 28);
        gotobutton.setBounds(180, 84, 80, 28);
        gotobutton.setContentAreaFilled(false);
        cancel.setBounds(270, 84, 80, 28);
        cancel.setContentAreaFilled(false);

        gotoDialog.setBounds(200, 200, 400, 160);
        gotoDialog.setResizable(false);
        con.add(linenumber);
        con.add(field);
        con.add(gotobutton);
        con.add(cancel);
        gotoDialog.setVisible(true);

        try{
            int pos = jtext.getCaretPosition();
            int row = jtext.getLineOfOffset(pos)+1;//将组件文本中的偏移量转换为行号
            field.setText(String.valueOf(row));
            field.requestFocus(); 
            field.selectAll();
        }catch(BadLocationException badlocation){
            System.out.println("bad location");
        }
    }

    public class MenuHandler implements ActionListener {
        @Override
        public void actionPerformed(ActionEvent e){
            String actionCommand = e.getActionCommand();
            //处理新建操作
            if("newfile".equals(actionCommand)){
                int select=showSaveDialog();
                if (select == JOptionPane.CANCEL_OPTION||select == JOptionPane.CLOSED_OPTION)// 取消按钮，则返回
                    return;
                else{
                    jtext.replaceRange("",0,jtext.getText().length());   
                    setTitle("无标题 - 记事本");
                    filepath=null;
                    undom.discardAllEdits(); //撤消所有的"撤消"操作  
                    edit_undo.setEnabled(false);
                }
            }
            //处理新窗口操作
            if("newwindow".equals(actionCommand)){
                new MyNotepad().init();
            }
            //处理打开操作
            if("open".equals(actionCommand)){
                // 是否保存对原文件修改
                int select = showSaveDialog();
                if (select == JOptionPane.CANCEL_OPTION||select == JOptionPane.CLOSED_OPTION)// 取消、关闭按钮，则返回
                    return;
                // 弹出一个 "Open File" 文件选择器对话框
                select = jfilechoose.showOpenDialog(MyNotepad.this);
                // 选择打开文件，则读写文件
                if (select == JFileChooser.APPROVE_OPTION) {
                    jtext.setText(readFile());// 写入文本框
                    jtext.setCaretPosition(0);// 定位光标至行首
                    undom.discardAllEdits(); //撤消所有的"撤消"操作  
                    edit_undo.setEnabled(false);
                }
            }
            //处理保存操作
            if("save".equals(actionCommand)){
                showSaveDialog();//调用文件是否保存方法
                setTitle(name + " - 记事本");
            }
            //处理另存为操作
            if("saveas".equals(actionCommand)){
                createFile();
                setTitle(name + " - 记事本");
            }
            //处理退出操作
            if("exit".equals(actionCommand)){
                int select = showSaveDialog();
                if (select != JOptionPane.CANCEL_OPTION && 
                select != JOptionPane.CLOSED_OPTION)
                    dispose();//释放窗体，dispose()
            }
            //处理撤销操作
            if("undo".equals(actionCommand)){
                if(undom.canUndo())
                    undom.undo();
                else
                    edit_undo.setEnabled(false);
            }
            //处理剪切操作
            if("cut".equals(actionCommand)){
                jtext.requestFocus();  
                String text=jtext.getSelectedText();
                //StringSelection实现的所有接口ClipboardOwner，Transferable 
                StringSelection selection=new StringSelection(text);  
                clipBoard.setContents(selection,null);  
                jtext.replaceRange("",jtext.getSelectionStart(),jtext.getSelectionEnd());  
                checkMenuItemEnabled();//设置剪切，复制，粘帖，删除功能的可用性
            }
            //处理复制操作
            if("copy".equals(actionCommand)){
                jtext.requestFocus();  
                String text=jtext.getSelectedText();  
                StringSelection selection=new StringSelection(text);  
                clipBoard.setContents(selection,null);  
                checkMenuItemEnabled();//设置剪切，复制，粘帖，删除功能的可用性
            }
            //处理粘贴操作
            if("stickup".equals(actionCommand)){
                jtext.requestFocus();  
                //只有一种类型的数据可以复制到剪贴板或者从剪贴板中取出，即Transferable对象。
                Transferable contents=clipBoard.getContents(this);  
                if(contents==null)
                    return;  
                String text="";  
                try  
                {   
                    //getTransferData返回一个对象，该对象表示将要被传输的数据。返回对象的类是由该 flavor 的表示类定义的
                    //DataFlavor.stringFlavor:The representing a Java Unicode String class
                    text=(String)contents.getTransferData(DataFlavor.stringFlavor);  
                }  
                catch (Exception exception)  
                {  
                }  
                jtext.replaceRange(text,jtext.getSelectionStart(),jtext.getSelectionEnd());  
                checkMenuItemEnabled();
            }
            //处理删除操作
            if("delete".equals(actionCommand)){
                jtext.requestFocus();  
                jtext.replaceRange("",jtext.getSelectionStart(),jtext.getSelectionEnd());  
                checkMenuItemEnabled(); //设置剪切、复制、粘贴、删除等功能的可用性
            }
            //处理查找窗口打开操作
            if("findwindow".equals(actionCommand)){
                jtext.requestFocus();  
                findwindow(); 
            }
            //处理查找下一个按钮操作
            if("findnext".equals(actionCommand)||"findnext1".equals(actionCommand)){
                int k=0; 
                String str1,str2,str3,str4,strA,strB;
                Boolean up,down,checkbox;
                str1=jtext.getText();
                if("findnext".equals(actionCommand)){//查找窗口的查找下一个按钮事件监听处理
                    str2=findText.getText();//查找窗口的查找内容
                    up=upButton.isSelected();
                    down=downButton.isSelected();
                    checkbox=matchCheckBox.isSelected();
                }
                else{//替换窗口的查找下一个按钮事件监听处理
                    str2=findText1.getText();//替换窗口的查找内容
                    up=upButton1.isSelected();
                    down=downButton1.isSelected();
                    checkbox=matchCheckBox1.isSelected();
                }
                str3=str1.toUpperCase();  
                str4=str2.toUpperCase();  
                if(checkbox)//区分大小写的JCheckBox是否被选中 
                {   strA=str1;  
                    strB=str2;  
                }  
                else//不区分大小写,此时把所选内容全部化成大写(或小写)，以便于查找   
                {   strA=str3;  
                    strB=str4;  
                }  
                if(up)  
                {      
                    if(jtext.getSelectedText()==null)
                        k=strA.lastIndexOf(strB,jtext.getCaretPosition()-1);//光标与其后一个字符位置下标相同
                    else
                        k=strA.lastIndexOf(strB, jtext.getCaretPosition()-strB.length()-1);
                    if(k>-1)//查找内容存在
                    {    
                        jtext.setCaretPosition(k);//设置光标位置
                        jtext.select(k,k+strB.length());//选中内容，此时光标位置后移了strB.length()长度
                    }  
                    else  
                        JOptionPane.showMessageDialog(null,"找不到\""+str2+"\"","记事本",JOptionPane.INFORMATION_MESSAGE);   
                }  
                else if(down)  
                {   
                    k=strA.indexOf(strB,jtext.getCaretPosition());      
                    if(k>-1)  
                    {   
                        jtext.setCaretPosition(k);
                        jtext.select(k,k+strB.length());  
                    }  
                    else  
                        JOptionPane.showMessageDialog(null,"找不到\""+str2+"\"","记事本",JOptionPane.INFORMATION_MESSAGE);   
                }  
            }
            //处理取消查找操作
            if("findcancel".equals(actionCommand)){
                findDialog.dispose();//关闭查找窗口
            }
            //处理快速查找下一个操作
            if("fastfindnext".equals(actionCommand)){
                int k=0;  
                String str1,str2;
                str1=jtext.getText();
                if(jtext.getSelectedText()==null){
                    JOptionPane.showMessageDialog(null,"请用光标从左向右选中待查找内容","提醒",JOptionPane.INFORMATION_MESSAGE);
                    return;
                }
                str2=jtext.getSelectedText(); 
                k=str1.indexOf(str2,jtext.getCaretPosition());      
                if(k>-1)  
                {   
                    jtext.setCaretPosition(k);
                    jtext.select(k,k+str2.length());  
                }  
                else  
                    JOptionPane.showMessageDialog(null,"找不到\""+str2+"\"","记事本",JOptionPane.INFORMATION_MESSAGE);    
            }
            //处理快速查找上一个操作
            if("fastfindpre".equals(actionCommand)){
                int k=0;  
                String str1,str2;
                str1=jtext.getText();
                if(jtext.getSelectedText()==null){
                    JOptionPane.showMessageDialog(null,"请用光标从左向右选中待查找内容","提醒",JOptionPane.INFORMATION_MESSAGE);
                    return;
                }
                str2=jtext.getSelectedText();  
                k=str1.lastIndexOf(str2, jtext.getCaretPosition()-str2.length()-1);
                if(k>-1)//查找内容存在
                {    
                    jtext.setCaretPosition(k);//设置光标位置
                    jtext.select(k,k+str2.length());//选中内容，此时光标位置后移了strB.length()长度
                }  
                else  
                    JOptionPane.showMessageDialog(null,"找不到\""+str2+"\"","记事本",JOptionPane.INFORMATION_MESSAGE);       
            }
            //处理替换窗口打开操作
            if("replacewindow".equals(actionCommand)){
                jtext.requestFocus();  
                replacewindow(); 
            }
            //处理替换操作
            if("replace".equals(actionCommand)){   
                if(jtext.getSelectedText()!=null&&
                    jtext.getSelectedText().equals(findText1.getText()))   
                    jtext.replaceSelection(replaceText.getText());
                int k=0;  
                String str1,str2,strA,strB;
                boolean up,down,checkbox;
                str1=jtext.getText();
                str2=findText1.getText();
                up=upButton1.isSelected();
                down=downButton1.isSelected();
                checkbox=matchCheckBox1.isSelected();
                if(checkbox){
                    strA=str1;
                    strB=str2;
                }
                else{
                    strA=str1.toUpperCase();
                    strB=str2.toUpperCase();
                }
                if(down){
                    k=strA.indexOf(strB,jtext.getCaretPosition());      
                    if(k>-1)  
                    {   
                        jtext.setCaretPosition(k);
                        jtext.select(k,k+strB.length());  
                    }  
                    else  
                        JOptionPane.showMessageDialog(null,"找不到\""+str2+"\"","记事本",JOptionPane.INFORMATION_MESSAGE);
                }
                if(up){
                    if(jtext.getSelectedText()==null)
                        k=strA.lastIndexOf(strB,jtext.getCaretPosition()-1);
                    else
                        k=strA.lastIndexOf(strB, jtext.getCaretPosition()-strB.length()-1);
                    if(k>-1)//查找内容存在
                    {    
                        jtext.setCaretPosition(k);//设置光标位置
                        jtext.select(k,k+strB.length());//选中内容，此时光标位置后移了strB.length()长度
                    }  
                    else  
                        JOptionPane.showMessageDialog(null,"找不到\""+str2+"\"","记事本",JOptionPane.INFORMATION_MESSAGE);
                }
                
            }
            //处理替换全部操作
            if("replaceall".equals(actionCommand)){
                // jtext.setCaretPosition(0);   //将光标放到编辑区开头
                String str1,str2,strA,strB;
                boolean up,down,checkbox;
                str1=jtext.getText();
                str2=findText1.getText();
                up=upButton1.isSelected();
                down=downButton1.isSelected();
                checkbox=matchCheckBox1.isSelected();
                if(checkbox)//区分大小写  
                {   strA=str1;  
                    strB=str2;  
                }  
                else//不区分大小写,此时把所选内容全部化成大写，以便于查找   
                {   strA=str1.toUpperCase();  
                    strB=str2.toUpperCase();  
                }  
                int k=0,replaceCount=0;  
                if(findText1.getText().length()==0)  
                {   JOptionPane.showMessageDialog(replaceDialog,"请填写查找内容!","提示",JOptionPane.WARNING_MESSAGE);  
                    findText1.requestFocus(true);  
                    return;  
                }  
                while(k>-1)//当文本中有内容被选中时(k>-1被选中)进行替换，否则不进行while循环  
                {       
                    if(up)  
                    {     
                        if(jtext.getSelectedText()==null)  
                            k=strA.lastIndexOf(strB,jtext.getCaretPosition()-1);  
                        else  
                            k=strA.lastIndexOf(strB,jtext.getCaretPosition()-strB.length()-1);      
                        if(k>-1)  
                        {     
                            jtext.setCaretPosition(k);  
                            jtext.select(k,k+strB.length());  
                        }  
                        else  
                        {   if(replaceCount==0)  
                                JOptionPane.showMessageDialog(replaceDialog, "找不到\""+str2+"\"", "记事本",JOptionPane.INFORMATION_MESSAGE);     
                            else  
                                JOptionPane.showMessageDialog(replaceDialog,"成功替换了"+replaceCount+"个匹配内容!","替换成功",JOptionPane.INFORMATION_MESSAGE);   
                        }  
                    }  
                    else if(down)  
                    { 
                        k=strA.indexOf(strB,jtext.getCaretPosition());       
                        if(k>-1)  
                        {     
                            jtext.setCaretPosition(k);  
                            jtext.select(k,k+strB.length());  
                        }  
                        else  
                        {   if(replaceCount==0)  
                                JOptionPane.showMessageDialog(replaceDialog, "找不到\""+str2+"\"", "记事本",JOptionPane.INFORMATION_MESSAGE);    
                            else  
                                JOptionPane.showMessageDialog(replaceDialog,"成功替换了"+replaceCount+"个匹配内容!","替换成功",JOptionPane.INFORMATION_MESSAGE);   
                        }  
                    }  
                    if(jtext.getSelectedText()!=null && jtext.getSelectedText().equals(findText1.getText()))   
                    {   jtext.replaceSelection(replaceText.getText());   
                        replaceCount++;  
                    }  
                }//while循环结束  
            }
            //处理取消替换操作
            if("replacecancel".equals(actionCommand)){
                replaceDialog.dispose();
            }
            //处理打开转到窗口操作
            if("gotowindow".equals(actionCommand)){
                jtext.requestFocus();
                gotowindow();
            }
            //处理转到按钮点击事件
            if("goto".equals(actionCommand)){
                int row = jtext.getLineCount();// 确定行数
                String str[] = jtext.getText().split("\n");
                int count = 0;
                try {
                    count = Integer.parseInt(field.getText().trim());//trim:去头尾空白字符 parseInt:字符转数字
                } catch (Exception e2) {
                    JOptionPane.showMessageDialog(null, "请输入要转到的行数！");
                }
                if (count <= row) {
                    int sum = 0;
                    for (int i = 0; i < count - 1; i++) {
                        sum += str[i].length() + 1;
                    }
                    jtext.setCaretPosition(sum);
                } else {
                    JOptionPane.showMessageDialog(null, "行数超过了总行数！");
                }
                gotoDialog.dispose();
            }
            //处理转到界面取消按钮点击事件
            if("gotocancel".equals(actionCommand)){
                gotoDialog.dispose();
            }
            //处理全选操作
            if("selectall".equals(actionCommand)){
                jtext.selectAll();
            }
            //时间/日期点击事件处理
            if("time".equals(actionCommand)){
                Date date = new Date();// 获得当前日期
                /*
                 * 日期格式化SimpleDateFormat h小时，m分钟 y年份 M月份 d天数
                 */
                SimpleDateFormat dateformat = new SimpleDateFormat("hh:mm yyyy-MM-dd");
                jtext.append(dateformat.format(date));// 追加到文本
            }
            //自动换行按钮点击处理
            if("linewrap".equals(actionCommand)){
                if(format_linewrap.getState())  
                    jtext.setLineWrap(true);//自动换行
                else   
                    jtext.setLineWrap(false);//不自动换行
            }
            //字体变大
            if("sizetobig".equals(actionCommand)){
                String name = jtext.getFont().getFontName();// 返回字体外观
                int style = jtext.getFont().getStyle();// 获得字体的样式
                int size = jtext.getFont().getSize();// 获得字体的大小
                jtext.setFont(new Font(name, style, size + 1));// 设置字体大小+1
            }
            //字体变小
            if("sizetosmall".equals(actionCommand)){
                String name = jtext.getFont().getFontName();
                int style = jtext.getFont().getStyle();
                int size = jtext.getFont().getSize();
                jtext.setFont(new Font(name, style, size - 1));// 设置字体大小-1
            }
            //恢复默认字体大小
            if("sourcesize".equals(actionCommand)){
                jtext.setFont(new Font("宋体", Font.PLAIN, 14));
            }
        }
    }
    // 读取文件
    private String readFile() {
        // 声明缓冲字符流变量
        BufferedReader br = null;
        //BufferedReader是从缓冲区之中读取内容
        StringBuilder sb = null;
        try {
            br = new BufferedReader(new FileReader(jfilechoose.getSelectedFile()));
            sb = new StringBuilder();//构造一个字符串构建器，其中不包含任何字符，初始容量为16个字符。
            String str;
            int count = 0;//控制添加换行符，与原文保持一致
            while ((str = br.readLine()) != null) {//读取一行内容，直到换行符，但不读取换行符
                if (count == 0){
                    sb.append(str);
                    count=1;
                }
                else
                    sb.append("\n" + str);// 添加换行
            }
        } catch (FileNotFoundException e1) {
            // 弹出“文件未找到”对话框，返回null
            JOptionPane.showMessageDialog(null, "未找到该文件！");
            return null;
        } catch (IOException e1) {
            // 弹出“文件读取异常”对话框，返回null
            JOptionPane.showMessageDialog(null, "文件读取异常");
            return null;
        } finally {
            // 关闭字符流
            if (br != null)
                try {
                    br.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                }
        }
        File file = jfilechoose.getSelectedFile();
        name = file.getName();
        filepath = file.getAbsolutePath();
        setTitle(name + " - 记事本");//设置文件名
        return sb.toString();
    }
 
    // 保存对话框
    private int showSaveDialog() {
        int select = 0;
        // 判断文件是否已存在
        if (filepath == null) {
            select = JOptionPane.showConfirmDialog(MyNotepad.this, "是否保存修改?");
            if (select == JOptionPane.YES_OPTION)
                createFile();//文件不存在，则创建文件
        } 
        else {
            if (!isSaved()){// 文件未保存
                select = JOptionPane.showConfirmDialog(MyNotepad.this, "是否保存修改?");
                if(select == JOptionPane.YES_OPTION)
                    saveFile(jfilechoose.getSelectedFile());
            }
        }
        return select;// 返回选项
    }
 
    // 创建新文件
    private void createFile() {
        // String name = null;
        File file = null;
        // 选择保存或取消
        if (jfilechoose.showSaveDialog(MyNotepad.this) == JFileChooser.APPROVE_OPTION)
            file = jfilechoose.getSelectedFile();// 获取选中的文件
        else
            return;
        name = jfilechoose.getName(file);// 获取输入的文件名
        filepath = file.getAbsolutePath();//获取文件的绝对路径
        if (file.exists()) { // 若选择已有文件----询问是否要覆盖
            int select = JOptionPane.showConfirmDialog(null, "该文件已存在,是否覆盖原文件", "确认", JOptionPane.YES_NO_OPTION);
            if (select == JOptionPane.YES_OPTION)
                saveFile(file);
            else
                jfilechoose.showSaveDialog(MyNotepad.this);// 重新选择
        } 
        else//文件不存在，则直接保存
            saveFile(file);
    }
 
    // 判断文件是否保存
    private Boolean isSaved() {
        // 比较内容
        if (jtext.getText().equals(readFile()))
            return true;
        return false;
    }
 
    // 保存文件
    private void saveFile(File file) {
        BufferedWriter bw = null;
        try {
            bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file)));
            bw.write(jtext.getText());//写入文件
            bw.flush();
        } catch (FileNotFoundException e1) {
            JOptionPane.showMessageDialog(MyNotepad.this, "文件保存出错" + e1.getMessage());
        } catch (IOException e1) {
            e1.printStackTrace();
        } finally {
            try {
                if (bw != null)
                    bw.close();
            } catch (IOException e1) {
            }
        }
    }
    //设置菜单项的可用性：剪切，复制，粘帖，删除功能  
    private void checkMenuItemEnabled()  
    {   String selectText=jtext.getSelectedText();  
        if(selectText==null)  
        {   edit_cut.setEnabled(false);    
            edit_copy.setEnabled(false);   
            edit_delete.setEnabled(false);   
        }  
        else  
        {   edit_cut.setEnabled(true);    
            edit_copy.setEnabled(true);   
            edit_delete.setEnabled(true);  
        }  
        //粘帖功能可用性判断  
        Transferable contents=clipBoard.getContents(MyNotepad.this);  
        if(contents==null)  
        {   edit_paste.setEnabled(false);  
        }  
        else  
        {   edit_paste.setEnabled(true);    
        }  
    }//方法checkMenuItemEnabled()结束 
    //实现DocumentListener接口中的方法(与撤销操作有关)，文档发生变化时就能触发DocumentEvent事件  
    public void removeUpdate(DocumentEvent e)//文档被移除  
    {   edit_undo.setEnabled(true);  
    }  
    public void insertUpdate(DocumentEvent e)//文档被插入 
    {   edit_undo.setEnabled(true);  
    }  
    public void changedUpdate(DocumentEvent e)//文档被改变 
    {   edit_undo.setEnabled(true);
    } 
    //实现接口UndoableEditListener的类UndoHandler(与撤销操作有关)  
    class UndoHandler implements UndoableEditListener  
    {   public void undoableEditHappened(UndoableEditEvent uee)  
        {   undom.addEdit(uee.getEdit());  
        }  
    }
}