• 第二十二章《记事本》第3节：项目完整代码

    记事本项目总共有7个类，这7个类的作用已在22.1.2小节中做过介绍，此处不再赘述，以下是这7个类的源代码，读者也能在本书提供的源代码文件夹中直接下载它们。

    NoteBookFrame.java

    1. import java.awt.*;
    2. import java.awt.event.*;
    3. import javax.swing.*;
    4. import java.io.*;
    5. import javax.swing.event.*;
    6. import javax.print.*;
    7. import javax.print.attribute.*;
    8. import java.nio.charset.Charset;
    9. import java.util.*;
    10. import java.text.*;
    11.  
    12. public class NoteBookFrame extends JFrame {
    13.  
    14.     JScrollPane JSPane;//放置文本区的滚动面板
    15.     JTextArea text;//记事本文本区
    16.     JMenuBar mainMenuBar;//菜单蓝
    17.     JMenu fileMenu, editMenu, formatMenu, helpMenu;//各菜单
    18.     //File菜单的菜单项
    19.     JMenuItem newItem, openItem, saveItem, saveasItem, pageItem, printItem, exitItem;
    20.     // 编辑菜单的菜单项
    21.     JMenuItem undoItem, cutItem, copyItem, pasteItem, findItem, replaceItem, selectallItem, dateItem;
    22.     //检查框菜单项，用于设置是否自动换行
    23.     JCheckBoxMenuItem wrapItem;
    24.     //字体设置菜单项
    25.     JMenuItem fontItem;
    26.     //帮助主题和关于菜单项
    27.     JMenuItem helpItem, aboutItem;
    28.     //右键菜单
    29.     JPopupMenu popMenu;
    30.     //字体设置对话框
    31.     FontDialog myFontDialog = null;
    32.     boolean changed = false;
    33.     boolean haveName = false;
    34.     //当前打开的这个文件
    35.     File file = null;
    36.     //当前文件的字符编码
    37.     String charSet = new String("");
    38.     //创建一个事件监听器对象
    39.     ActionListenerImpl listener = new ActionListenerImpl();
    40.     //初始化窗体组件
    41.     private void init() {
    42.         Container container = this.getContentPane();
    43.         text = new JTextArea();
    44.         JSPane = new JScrollPane(text);
    45.         container.add(JSPane, BorderLayout.CENTER);
    46.         createMenu();//创建主菜单
    47.         createPopupMenu();//创建弹出式菜单
    48.         this.setJMenuBar(mainMenuBar);//设置菜单
    49.         text.setComponentPopupMenu(popMenu);
    50.         //为文本区添加监听器
    51.         text.getDocument().addDocumentListener(new DocumentListener() {
    52.             @Override
    53.             public void insertUpdate(DocumentEvent e) {
    54.                 changed = true;
    55.             }
    56.  
    57.             @Override
    58.             public void removeUpdate(DocumentEvent e) {
    59.                 changed = true;
    60.             }
    61.  
    62.             @Override
    63.             public void changedUpdate(DocumentEvent e) {
    64.                 //不需要动作
    65.             }
    66.         });
    67.         //为文本区添加键盘监听器
    68.         text.addKeyListener(new HandleKey());
    69.         //为文本区添加键盘监听器
    70.         text.addMouseListener(new HandleMouse());
    71.     }
    72.  
    73.     //创建界面、安装各种监听器、
    74.     public NoteBookFrame() {
    75.         init();
    76.     }
    77.  
    78.     //创建主菜单
    79.     public void createMenu() {
    80.         //创建JMenuBar
    81.         mainMenuBar = new JMenuBar();
    82.         //创建四个JMenu
    83.         fileMenu = new JMenu("文件");
    84.         editMenu = new JMenu("编辑");
    85.         formatMenu = new JMenu("格式");
    86.         helpMenu = new JMenu("帮助");
    87.         //创建JMenuItem并添加到对应的JMenu中
    88.         mainMenuBar.add(fileMenu);
    89.         newItem = new JMenuItem("新建");
    90.         openItem = new JMenuItem("打开..");
    91.         saveItem = new JMenuItem("保存..");
    92.         saveasItem = new JMenuItem("另存为..");
    93.         pageItem = new JMenuItem("页面设置..");
    94.         printItem = new JMenuItem("打印..");
    95.         exitItem = new JMenuItem("退出");
    96.         fileMenu.add(newItem);
    97.         fileMenu.add(openItem);
    98.         fileMenu.add(saveItem);
    99.         fileMenu.add(saveasItem);
    100.         fileMenu.addSeparator();
    101.         fileMenu.add(pageItem);
    102.         fileMenu.add(printItem);
    103.         fileMenu.addSeparator();
    104.         fileMenu.add(exitItem);
    105.  
    106.         mainMenuBar.add(editMenu);
    107.         undoItem = new JMenuItem("撤消");
    108.         cutItem = new JMenuItem("剪切");
    109.         copyItem = new JMenuItem("复制");
    110.         pasteItem = new JMenuItem("粘贴");
    111.         findItem = new JMenuItem("查找..");
    112.         replaceItem = new JMenuItem("替换..");
    113.         selectallItem = new JMenuItem("全选");
    114.         dateItem = new JMenuItem("时间/日期");
    115.         editMenu.add(undoItem);
    116.         editMenu.addSeparator();
    117.         editMenu.add(cutItem);
    118.         editMenu.add(copyItem);
    119.         editMenu.add(pasteItem);
    120.         editMenu.addSeparator();
    121.         editMenu.add(findItem);
    122.         editMenu.add(replaceItem);
    123.         editMenu.addSeparator();
    124.         editMenu.add(selectallItem);
    125.         editMenu.add(dateItem);
    126.  
    127.         mainMenuBar.add(formatMenu);
    128.         wrapItem = new JCheckBoxMenuItem("自动换行");
    129.         fontItem = new JMenuItem("设置字体..");
    130.         formatMenu.add(wrapItem);
    131.         formatMenu.add(fontItem);
    132.         mainMenuBar.add(helpMenu);
    133.         helpItem = new JMenuItem("帮助主题");
    134.         aboutItem = new JMenuItem("关于..");
    135.         helpMenu.add(helpItem);
    136.         helpMenu.add(aboutItem);
    137.  
    138.         exitItem.addActionListener(listener);
    139.         saveItem.addActionListener(listener);
    140.         saveasItem.addActionListener(listener);
    141.         newItem.addActionListener(listener);
    142.         printItem.addActionListener(listener);
    143.         openItem.addActionListener(listener);
    144.         cutItem.addActionListener(listener);
    145.         copyItem.addActionListener(listener);
    146.         pasteItem.addActionListener(listener);
    147.         selectallItem.addActionListener(listener);
    148.         dateItem.addActionListener(listener);
    149.         wrapItem.addActionListener(listener);
    150.         findItem.addActionListener(listener);
    151.         fontItem.addActionListener(listener);
    152.     }
    153.  
    154.     //创建弹出式菜单
    155.     public void createPopupMenu() {
    156.         popMenu = new JPopupMenu();
    157.         popMenu.add("撤消");
    158.         popMenu.addSeparator();
    159.         popMenu.add("剪切");
    160.         popMenu.add("复制");
    161.         popMenu.add("粘贴");
    162.         popMenu.addSeparator();
    163.         popMenu.add("全选");
    164.     }
    165.  
    166.     //重写父类方法，当用户按下窗口的“关闭”时，会自动调用此方法
    167.     protected void processWindowEvent(WindowEvent e) {
    168.         if (e.getID() == WindowEvent.WINDOW_CLOSING) {
    169.             doExit();
    170.         }
    171.     }
    172.  
    173.     //根据用户选择文本的情况，修改菜单的状态
    174.     void checkSelected() {
    175.         if (text.getSelectedText() == null) {
    176.             cutItem.setEnabled(false);
    177.             copyItem.setEnabled(false);
    178.         } else {
    179.             cutItem.setEnabled(true);
    180.             copyItem.setEnabled(true);
    181.         }
    182.     }
    183.  
    184.     //退出记事本
    185.     void doExit() {
    186.         int select;
    187.         boolean flag = false;
    188.         if (!changed)
    189.             System.exit(0);
    190.         else {
    191.             select = JOptionPane.showConfirmDialog(this, "文件修改后尚未保存，要保存吗？");
    192.             if(select==JOptionPane.YES_OPTION){
    193.                 flag = doSave();
    194.                 if (flag == true) {
    195.                     System.exit(0);
    196.                 }
    197.             }else if(select==JOptionPane.NO_OPTION){
    198.                 System.exit(0);
    199.             }
    200.         }
    201.     }
    202.  
    203.     //保存用户编辑的文件，保存成功返回1，否则返回0
    204.     boolean doSave() {
    205.         FileWriter fr = null;
    206.         String content;
    207.         boolean flag;
    208.         if (!haveName) {
    209.             flag = doSaveAs();
    210.         } else if (changed) {
    211.             try {
    212.                 fr = new FileWriter(file,Charset.forName(charSet));
    213.                 content = text.getText();
    214.                 if (!"GBK".equals(charSet)) {//如果不是GBK(ANSI)则先写BOM
    215.                     fr.write("\uFEFF");
    216.                 }
    217.                 fr.write(content);
    218.                 changed = false;//修改完后文件改变置为false
    219.                 flag = true;
    220.             } catch (FileNotFoundException e) {
    221.                 JOptionPane.showMessageDialog(this, "指定的文件名称或属性有问题！");
    222.                 flag = false;
    223.             } catch (IOException e) {
    224.                 JOptionPane.showMessageDialog(this, "无法写文件，请检查文件是否被锁定");
    225.                 flag = false;
    226.             } finally {
    227.                 closeWriter(fr);
    228.             }
    229.         } else {
    230.             flag = true;
    231.         }
    232.         return flag;
    233.     }
    234.  
    235.     //用"另存为"对话框保存文件。保存成功返回true，否则返回false
    236.     boolean doSaveAs() {
    237.         boolean flag = false;
    238.         File tmpfile = null;
    239.         ExampleFileFilter filter = new ExampleFileFilter();
    240.         filter.addExtension("txt");
    241.         filter.setDescription("文本文件");
    242.         SaveDialog dialog;
    243.         String thisCharSet = new String("");//本次保存的编码类型
    244.         if (file == null) {//如果目前操作的是一个没被保存过的文件
    245.             dialog = new SaveDialog(filter);
    246.         } else {
    247.             dialog = new SaveDialog(filter, file.getPath(),charSet);
    248.         }
    249.         SaveType saveType = dialog.getSaveType();
    250.         if (saveType != null) {   //确定要保存文件
    251.             String encode = saveType.getEncode();
    252.             tmpfile = saveType.getFile();
    253.             thisCharSet = getEncodeType(encode);
    254.             String absolutePath = tmpfile.getAbsolutePath();
    255.             if (saveType.isTxtFile()) {  //如果是文本文件方式存储
    256.                 String extension = absolutePath.substring(absolutePath.length() - 4);
    257.                 if (!extension.equalsIgnoreCase(".txt")) {//如果不以txt为后缀
    258.                     absolutePath = absolutePath + ".txt";//为其增加后缀
    259.                     tmpfile = new File(absolutePath);
    260.                 }
    261.             }
    262.             flag = true;
    263.         } else {
    264.             flag = false;
    265.         }
    266.  
    267.         if (flag == true) {  //用户已经确定要以指定名称保存文件
    268.             FileWriter fr = null;
    269.             try {
    270.                 fr = new FileWriter(tmpfile,Charset.forName(thisCharSet));
    271.                 String content = text.getText();
    272.                 if (!"GBK".equals(thisCharSet)) {//如果不是GBK(ANSI)则先写BOM
    273.                     fr.write("\uFEFF");
    274.                 }
    275.                 fr.write(content);
    276.                 flag = true;
    277.             } catch (FileNotFoundException e) {
    278.                 JOptionPane.showMessageDialog(this, "指定的文件名称或属性有问题！");
    279.                 flag = false;
    280.             } catch (IOException e) {
    281.                 JOptionPane.showMessageDialog(this, "无法写文件，请检查文件是否被锁定");
    282.                 flag = false;
    283.             }finally {
    284.                 closeWriter(fr);
    285.             }
    286.         }
    287.  
    288.         if (flag == true) {//文件保存成功，修改相关变量
    289.             changed = false;
    290.             haveName = true;
    291.             file = tmpfile;
    292.             charSet = thisCharSet;
    293.             this.setTitle("记事本 -- " + file.getName());
    294.         }
    295.         return flag;
    296.     }
    297.  
    298.     //新建一个文件
    299.     void doNewFile() {
    300.         int select;
    301.         boolean flag = false;
    302.         if (changed) {
    303.             select = JOptionPane.showConfirmDialog(this, "文件修改后尚未存盘，要保存吗？");
    304.             switch (select) {
    305.                 case JOptionPane.YES_OPTION:
    306.                     flag = doSave();
    307.                     break;
    308.                 case JOptionPane.NO_OPTION:
    309.                     flag = true;
    310.                     break;
    311.                 default:
    312.                     flag = false;
    313.                     break;
    314.             }
    315.         } else {
    316.             flag = true;
    317.         }
    318.         if (flag == true) {
    319.             changed = false;
    320.             haveName = false;
    321.             charSet = "GBK";
    322.             setTitle("记事本 -- 未命名");
    323.             text.setText(null);
    324.         }
    325.     }
    326.  
    327.     //调用打印对话框，给用户打印文档
    328.     void doPrint() {
    329.         try {
    330.             //创建打印请求属性集
    331.             PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet();
    332.             //设置打印格式(自动)
    333.             DocFlavor flavor = DocFlavor.BYTE_ARRAY.AUTOSENSE;
    334.             //查找所有可用的打印服务
    335.             PrintService printService[] = PrintServiceLookup.lookupPrintServices(flavor, pras);
    336.             //定位默认打印机
    337.             PrintService defaultService = PrintServiceLookup.lookupDefaultPrintService();
    338.             PrintService service ;
    339.             //显示打印对话框
    340.             service = ServiceUI.printDialog(null, 100, 100, printService, defaultService, flavor, pras);
    341.             if (service != null) {
    342.                 //创建打印作业
    343.                 DocPrintJob job = service.createPrintJob();
    344.                 //创建文档属性集
    345.                 DocAttributeSet das = new HashDocAttributeSet();
    346.                 //建立打印格式文件
    347.                 Doc doc = new SimpleDoc(text.getText().getBytes(), flavor, das);
    348.                 //进行文件的打印
    349.                 job.print(doc, pras);
    350.             }
    351.         } catch (Exception e) {
    352.             JOptionPane.showMessageDialog(this, "打印任务无法完成");
    353.         }
    354.     }
    355.  
    356.     //打开一个已经存在的文件
    357.     void doOpen() {
    358.         int select;
    359.         boolean flag;
    360.         File tmpfile = null;
    361.         ExampleFileFilter filter;
    362.         JFileChooser chooser;
    363.         FileReader fr = null;
    364.         if (changed) {
    365.             select = JOptionPane.showConfirmDialog(this, "文件修改后尚未存盘，要保存吗？");
    366.             switch (select) {
    367.                 case JOptionPane.YES_OPTION:
    368.                     flag = doSave();
    369.                     break;
    370.                 case JOptionPane.NO_OPTION:
    371.                     flag = true;
    372.                     break;
    373.                 default:
    374.                     flag = false;
    375.                     break;
    376.             }
    377.         } else {
    378.             flag = true;
    379.         }
    380.         if (flag == true) {
    381.             changed = false;
    382.             filter = new ExampleFileFilter();
    383.             filter.addExtension("txt");
    384.             filter.setDescription("文本文件");
    385.             if (file != null) {
    386.                 chooser = new JFileChooser(file.getPath());
    387.             } else {
    388.                 chooser = new JFileChooser();
    389.             }
    390.             chooser.setFileFilter(filter);
    391.             select = chooser.showOpenDialog(this);
    392.             if (select == JFileChooser.APPROVE_OPTION) {
    393.                 tmpfile = chooser.getSelectedFile();
    394.                 try {
    395.                     String enCode = this.getEncode(tmpfile);
    396.  
    397.                     StringBuffer content = new StringBuffer("");
    398.                     fr = new FileReader(tmpfile, Charset.forName(enCode));
    399.                     if ("UTF-8".equals(enCode) || "UTF-16BE".equals(enCode) || "UTF-16LE".equals(enCode)) {
    400.                         fr.read();//提前读出
    401.                     }
    402.                     int read;
    403.                     while ((read = fr.read()) != -1) {
    404.                         content.append((char) read);
    405.                     }
    406.                     text.setText(content.toString());
    407.                     text.setCaretPosition(0);//设置插入点位置
    408.                     changed = false;
    409.                     haveName = true;
    410.                     file = tmpfile;//把所选择并打开的文件作为当前文件
    411.                     charSet = enCode;
    412.                     setTitle("记事本 -- " + file.getName());
    413.                 } catch (FileNotFoundException e) {
    414.                     JOptionPane.showMessageDialog(this, "指定的文件名称或属性有问题！");
    415.                 } catch (IOException e) {
    416.                     JOptionPane.showMessageDialog(this, "无法读文件，请检查文件是否被锁定");
    417.                 }
    418.             }
    419.         }
    420.     }
    421.  
    422.     //将用户选择的文本剪切到剪贴板
    423.     void doCut() {
    424.         text.cut();
    425.     }
    426.  
    427.     //将用户选择的文本复制到剪贴板
    428.     void doCopy() {
    429.         text.copy();
    430.     }
    431.  
    432.     //将剪贴板中的内容复制到文本区
    433.     void doPaste() {
    434.         text.paste();
    435.     }
    436.  
    437.     //全选
    438.     void doSelectAll() {
    439.         text.selectAll();
    440.     }
    441.  
    442.     //插入当前日期和时间
    443.     void doDateTime() {
    444.         SimpleDateFormat sdf = new SimpleDateFormat("HH:mm yyyy-MM-dd");
    445.         text.append(sdf.format(new Date()));
    446.     }
    447.  
    448.     //自动换行
    449.     void doWrap() {
    450.         if (wrapItem.getState()) {
    451.             text.setLineWrap(true);
    452.         } else {
    453.             text.setLineWrap(false);
    454.         }
    455.     }
    456.  
    457.     //显示查找对话框
    458.     void doFind() {
    459.         FindDialog dialog = new FindDialog(text);
    460.  
    461.         dialog.setLocationRelativeTo(null);
    462.         dialog.setTitle("查找");
    463.         dialog.setSize(300, 120);
    464.         dialog.setVisible(true);
    465.     }
    466.  
    467.     //设置字体
    468.     void doChangeFont() {
    469.         if (myFontDialog == null) {
    470.             myFontDialog = new FontDialog(this);
    471.         }
    472.         if (myFontDialog.showFontDialog() == FontDialog.OK) {
    473.             text.setFont(myFontDialog.getFont());//获得对话框返回的字体并以它作为记事本字体
    474.         }
    475.     }
    476.  
    477.     //获得文件的字符编码
    478.     private String getEncode(File file) throws FileNotFoundException, IOException {
    479.         String enCode = "";
    480.         FileInputStream fis = new FileInputStream(file);
    481.         byte[] head = new byte[3];
    482.         int read = fis.read(head, 0, 3);
    483.         if (read == -1) {//如果什么都没读到，则说明没有BOM，属于ANSI
    484.             enCode = "GB2312";
    485.         } else if (head[0] == (byte) 0XFF && head[1] == (byte) 0XFE) {
    486.             enCode = "UTF-16LE";
    487.         } else if (head[0] == (byte) 0XFE && head[1] == (byte) 0XFF) {
    488.             enCode = "UTF-16BE";
    489.         } else if (head[0] == (byte) 0XEF && head[1] == (byte) 0XBB && head[2] == (byte) 0XBF) {
    490.             enCode = "UTF-8";
    491.         } else {
    492.             enCode = "GB2312";
    493.         }
    494.         return enCode;
    495.     }
    496.  
    497.     //关闭输出流
    498.     void closeWriter(Writer writer) {
    499.         if (writer != null) {
    500.             try {
    501.                 writer.close();
    502.             } catch (IOException e) {
    503.                 e.printStackTrace();
    504.             }
    505.         }
    506.     }
    507.  
    508.     //关闭输入流
    509.     void closeReader(Reader reader) {
    510.         if (reader != null) {
    511.             try {
    512.                 reader.close();
    513.             } catch (IOException e) {
    514.                 e.printStackTrace();
    515.             }
    516.         }
    517.     }
    518.  
    519.     //把对话框的编码类型转换成实际的Charset名称
    520.     String getEncodeType(String name) {
    521.         String encode = "";
    522.         switch (name) {
    523.             case "ANSI":
    524.                 encode = "GBK";
    525.                 break;
    526.             case "Unicode":
    527.                 encode = "UTF-16LE";
    528.                 break;
    529.             case "Unicode big endian":
    530.                 encode = "UTF-16BE";
    531.                 break;
    532.             case "UTF-8":
    533.                 encode = "UTF-8";
    534.                 break;
    535.             default:
    536.                 encode = "GBK";
    537.         }
    538.         return encode;
    539.     }
    540.  
    541.     //定义监听器
    542.     //定义一个监听器的实现类用以监听各菜单项事件
    543.     class ActionListenerImpl implements ActionListener {
    544.         @Override
    545.         public void actionPerformed(ActionEvent e) {
    546.             Object obj;
    547.             obj = e.getSource();
    548.             if (obj == exitItem)
    549.                 doExit();
    550.             else if (obj == saveItem)
    551.                 doSave();
    552.             else if (obj == saveasItem)
    553.                 doSaveAs();
    554.             else if (obj == newItem)
    555.                 doNewFile();
    556.             else if (obj == printItem)
    557.                 doPrint();
    558.             else if (obj == openItem)
    559.                 doOpen();
    560.             else if (obj == cutItem)
    561.                 doCut();
    562.             else if (obj == copyItem)
    563.                 doCopy();
    564.             else if (obj == pasteItem)
    565.                 doPaste();
    566.             else if (obj == selectallItem)
    567.                 doSelectAll();
    568.             else if (obj == dateItem)
    569.                 doDateTime();
    570.             else if (obj == wrapItem)
    571.                 doWrap();
    572.             else if (obj == findItem)
    573.                 doFind();
    574.             else if (obj == fontItem)
    575.                 doChangeFont();
    576.         }
    577.     }
    578.     //键盘监听器类
    579.     class HandleKey extends KeyAdapter {
    580.         public void keyPressed(KeyEvent e) {
    581.             checkSelected();
    582.         }
    583.     }
    584.     //鼠标监听器类
    585.     class HandleMouse extends MouseAdapter {
    586.         public void mouseReleased(MouseEvent e) {
    587.             checkSelected();
    588.         }
    589.     }
    590. }

    FontDialog.java

    1. import java.awt.event.*;
    2. import javax.swing.*;
    3. import javax.swing.event.*;
    4. import java.awt.*;
    5. public class FontDialog extends JDialog {
    6.     public static final int Cancle = 0;
    7.     public static final int OK = 1;
    8.     public static final String[] style = {"正常", "斜体", "粗体", "粗斜体"};
    9.     public static final String[] size = {"8", "9", "10", "11", "12", "14", "16",
    10.             "18", "20", "22", "24", "26", "28", "36", "48", "72"};
    11.     private Font userFont = null;
    12.     private int userSelect = Cancle;
    13.     private JFrame parent = null;
    14.     private JScrollPane nameSPane, styleSPane, sizeSPane;
    15.     private JPanel panel[];
    16.     private JLabel lblName, lblStyle, lblSize;
    17.     private JTextField txtName, txtStyle, txtSize;
    18.     private JList nameList, styleList, sizeList;
    19.     private JButton btnOK, btnCancle;
    20.  
    21.     //定义一个动作监听器类
    22.     class ActionlistenerImpl implements ActionListener {
    23.         public void actionPerformed(ActionEvent e) {
    24.             int styleIndex = Font.PLAIN, fontSize;
    25.             if (e.getSource() == btnOK) {
    26.                 if (txtStyle.getText().equals("正常"))
    27.                     styleIndex = Font.PLAIN;
    28.                 if (txtStyle.getText().equals("斜体"))
    29.                     styleIndex = Font.ITALIC;
    30.                 if (txtStyle.getText().equals("粗体"))
    31.                     styleIndex = Font.BOLD;
    32.                 if (txtStyle.getText().equals("粗斜体"))
    33.                     styleIndex = Font.BOLD | Font.ITALIC;
    34.                 fontSize = Integer.parseInt(txtSize.getText());
    35.                 userFont = new Font(txtName.getText(), styleIndex, fontSize);
    36.                 userSelect = OK;
    37.                 setVisible(false);
    38.             } else {
    39.                 userSelect = Cancle;
    40.                 setVisible(false);
    41.             }
    42.         }
    43.     }
    44.  
    45.     //创建一个列表监听器类
    46.     class ListSelectionListenerImple implements ListSelectionListener {
    47.         public void valueChanged(ListSelectionEvent e) {
    48.             if (e.getSource() == nameList) {
    49.                 txtName.setText((String) nameList.getSelectedValue());
    50.             }
    51.             if (e.getSource() == styleList) {
    52.                 txtStyle.setText((String) styleList.getSelectedValue());
    53.             }
    54.             if (e.getSource() == sizeList) {
    55.                 txtSize.setText((String) sizeList.getSelectedValue());
    56.             }
    57.         }
    58.     }
    59.  
    60.     //创建监听器对象
    61.     ActionlistenerImpl listener = new ActionlistenerImpl();
    62.     ListSelectionListenerImple listSelectionListener = new ListSelectionListenerImple();
    63.  
    64.     private void init() {
    65.         setTitle("字体");
    66.         Container container = this.getContentPane();
    67.         BoxLayout box = new BoxLayout(container, BoxLayout.Y_AXIS);
    68.         container.setLayout(box);
    69.         panel = new JPanel[4];
    70.         for (int i = 0; i < 3; i++) {
    71.             panel[i] = new JPanel();
    72.             panel[i].setLayout(new GridLayout(1, 3));
    73.         }
    74.         panel[3] = new JPanel();
    75.         panel[3].setLayout(new FlowLayout());
    76.  
    77.         lblName = new JLabel("字体");
    78.         lblStyle = new JLabel("字形");
    79.         lblSize = new JLabel("大小");
    80.         panel[0].add(lblName);
    81.         panel[0].add(lblStyle);
    82.         panel[0].add(lblSize);
    83.  
    84.         txtName = new JTextField("宋体");
    85.         txtName.setColumns(5);
    86.         txtName.setEditable(false);
    87.         txtStyle = new JTextField("正常");
    88.         txtStyle.setColumns(5);
    89.         txtStyle.setEditable(false);
    90.         txtSize = new JTextField("12");
    91.         txtSize.setColumns(5);
    92.         txtSize.setEditable(false);
    93.         panel[1].add(txtName);
    94.         panel[1].add(txtStyle);
    95.         panel[1].add(txtSize);
    96.         GraphicsEnvironment eq = GraphicsEnvironment.getLocalGraphicsEnvironment();
    97.         String[] availableFonts = eq.getAvailableFontFamilyNames();
    98.         nameList = new JList(availableFonts);
    99.         nameList.addListSelectionListener(listSelectionListener);
    100.         nameSPane = new JScrollPane(nameList);
    101.         styleList = new JList(style);
    102.         styleList.addListSelectionListener(listSelectionListener);
    103.         styleSPane = new JScrollPane(styleList);
    104.         sizeList = new JList(size);
    105.         sizeList.addListSelectionListener(listSelectionListener);
    106.         sizeSPane = new JScrollPane(sizeList);
    107.         panel[2].add(nameSPane);
    108.         panel[2].add(styleSPane);
    109.         panel[2].add(sizeSPane);
    110.  
    111.         btnOK = new JButton("确定");
    112.         btnOK.addActionListener(listener);
    113.         btnCancle = new JButton("取消");
    114.         btnCancle.addActionListener(listener);
    115.         panel[3].add(btnOK);
    116.         panel[3].add(btnCancle);
    117.         for (int i = 0; i < 4; i++) {
    118.             container.add(panel[i]);
    119.         }
    120.  
    121.     }
    122.  
    123.     public FontDialog(JFrame owner) {
    124.         super(owner, true);
    125.         parent = owner;
    126.         init();
    127.     }
    128.  
    129.     public int showFontDialog() {
    130.         setSize(300, 300);
    131.         int x, y;
    132.         if (parent != null) {
    133.             x = parent.getX() + 30;
    134.             y = parent.getY() + 30;
    135.         } else {
    136.             x = 150;
    137.             y = 100;
    138.         }
    139.         setLocation(new Point(x, y));
    140.         setVisible(true);
    141.         return userSelect;
    142.     }
    143.  
    144.     public Font getFont() {
    145.         return userFont;
    146.     }
    147. }

    FindDialog.java

    1. import java.awt.*;
    2. import java.awt.event.*;
    3. import javax.swing.*;
    4. public class FindDialog extends JDialog {
    5.     JPanel panel1, panel2;
    6.     JTextArea text;
    7.     JLabel label1;
    8.     JTextField findEdit;
    9.     JCheckBox checkBox;
    10.     JRadioButton btnUp, btnDown;
    11.     ButtonGroup dirBtnGroup;
    12.     JButton btnOK, btnCancle;
    13.     int start;//查找开始位置
    14.     int curPosition;//原来光标的位置
    15.     //定义一个动作监听器类
    16.     class ActionlistenerImpl implements ActionListener {
    17.         public void actionPerformed(ActionEvent e) {
    18.             if (e.getSource() == btnOK) {
    19.                 find();
    20.             } else {
    21.                 dispose();
    22.             }
    23.         }
    24.     }
    25.  
    26.     //创建监听器对象
    27.     ActionlistenerImpl listener = new ActionlistenerImpl();
    28.  
    29.     private void init(JTextArea textArea) {
    30.         Container container = this.getContentPane();
    31.  
    32.         text = textArea;
    33.         curPosition = text.getCaretPosition();//初始光标的位置
    34.         start = curPosition;//设置初始查找位置为初始光标位置
    35.         panel1 = new JPanel();
    36.         panel1.setLayout(new FlowLayout());
    37.         panel2 = new JPanel();
    38.         panel2.setLayout(new FlowLayout());
    39.         label1 = new JLabel("查找内容");
    40.         findEdit = new JTextField(12);
    41.         btnOK = new JButton("查找下一个");
    42.         btnOK.addActionListener(listener);
    43.         panel1.add(label1);
    44.         panel1.add(findEdit);
    45.         panel1.add(btnOK);
    46.         checkBox = new JCheckBox("区分大小写");
    47.         checkBox.setSelected(true);
    48.         btnUp = new JRadioButton("向上");
    49.         btnDown = new JRadioButton("向下", true);
    50.         dirBtnGroup = new ButtonGroup();
    51.         dirBtnGroup.add(btnUp);
    52.         dirBtnGroup.add(btnDown);
    53.         btnCancle = new JButton("取消");
    54.         btnCancle.addActionListener(listener);
    55.         panel2.add(checkBox);
    56.         panel2.add(btnUp);
    57.         panel2.add(btnDown);
    58.         panel2.add(btnCancle);
    59.         container.setLayout(new FlowLayout());
    60.         container.add(panel1);
    61.         container.add(panel2);
    62.     }
    63.  
    64.     public FindDialog(JTextArea text) {
    65.         init(text);
    66.     }
    67.  
    68.     public void find() {
    69.         int index;
    70.         start = text.getCaretPosition();
    71.         String allText = text.getText();//记事本中的全部字符
    72.         String searchText = findEdit.getText();
    73.         if(checkBox.isSelected()==false) {//不区分大小写
    74.             allText = allText.toLowerCase();
    75.             searchText = searchText.toLowerCase();
    76.         }
    77.         if(btnDown.isSelected()) {//向下查找
    78.             index = allText.indexOf(searchText, start);
    79.             if (index < 0) {
    80.                 JOptionPane.showMessageDialog(this, "已查找全部文档");
    81.                 text.setCaretPosition(0);
    82.             } else {
    83.                 text.select(index, index + searchText.length());
    84.             }
    85.         }else {//向上查找
    86.             start--;
    87.             index = allText.lastIndexOf(searchText, start);
    88.             if (index < 0) {
    89.                 JOptionPane.showMessageDialog(this, "已查找全部文档");
    90.                 text.setCaretPosition(allText.length());
    91.             } else {
    92.                 text.setCaretPosition(index+searchText.length());
    93.                 text.moveCaretPosition(index);
    94.             }
    95.         }
    96.     }
    97. }

    ExampleFileFilter.java

    1. import java.io.File;
    2. import java.util.Hashtable;
    3. import java.util.Enumeration;
    4. import javax.swing.filechooser.*;
    5. public class ExampleFileFilter extends FileFilter {
    6.     private Hashtable filters = null;
    7.     private String description = null;
    8.     private String fullDescription = null;
    9.     private boolean useExtensionsInDescription = true;
    10.     public String toString(){
    11.         return description;
    12.     }
    13.     public ExampleFileFilter() {
    14.         this.filters = new Hashtable();
    15.     }
    16.  
    17.     public boolean accept(File f) {
    18.         if (f != null) {
    19.             if (f.isDirectory()) {
    20.                 return true;
    21.             }
    22.             String extension = getExtension(f);
    23.             if (extension != null && filters.get(getExtension(f)) != null) {
    24.                 return true;
    25.             }
    26.         }
    27.         return false;
    28.     }
    29.  
    30.     public String getExtension(File f) {
    31.         if (f != null) {
    32.             String filename = f.getName();
    33.             int i = filename.lastIndexOf('.');
    34.             if (i > 0 && i < filename.length() - 1) {
    35.                 return filename.substring(i + 1).toLowerCase();
    36.             }
    37.         }
    38.         return null;
    39.     }
    40.  
    41.     public void addExtension(String extension) {
    42.         if (filters == null) {
    43.             filters = new Hashtable(5);
    44.         }
    45.         filters.put(extension.toLowerCase(), this);
    46.         fullDescription = null;
    47.     }
    48.  
    49.     public String getDescription() {
    50.         if (fullDescription == null) {
    51.             if (isExtensionListInDescription()) {
    52.                 fullDescription = (description == null) ? "(" : description + " (";
    53.                 Enumeration extensions = filters.keys();
    54.                 if (extensions != null) {
    55.                     fullDescription += "*." + (String) extensions.nextElement();
    56.                     while (extensions.hasMoreElements()) {
    57.                         fullDescription += ", *." + (String) extensions.nextElement();
    58.                     }
    59.                 }
    60.                 fullDescription += ")";
    61.             } else {
    62.                 fullDescription = description;
    63.             }
    64.         }
    65.         return fullDescription;
    66.     }
    67.  
    68.     public void setDescription(String description) {
    69.         this.description = description;
    70.         fullDescription = null;
    71.     }
    72.  
    73.     public void setExtensionListInDescription(boolean b) {
    74.         useExtensionsInDescription = b;
    75.         fullDescription = null;
    76.     }
    77.  
    78.     public boolean isExtensionListInDescription() {
    79.         return useExtensionsInDescription;
    80.     }
    81. }

    SaveType.java

    1. import java.io.File;
    2. public class SaveType {
    3.     private File file;//要保存的文件
    4.     private String encode;//存储的类型
    5.     private boolean isTxtFile;
    6.     public File getFile() {
    7.         return file;
    8.     }
    9.  
    10.     public void setFile(File file) {
    11.         this.file = file;
    12.     }
    13.  
    14.     public String getEncode() {
    15.         return encode;
    16.     }
    17.  
    18.     public void setEncode(String encode) {
    19.         this.encode = encode;
    20.     }
    21.  
    22.     public boolean isTxtFile() {
    23.         return isTxtFile;
    24.     }
    25.  
    26.     public void setTxtFile(boolean txtFile) {
    27.         isTxtFile = txtFile;
    28.     }
    29. }

    SaveDialog.java

    1. import java.awt.Container;
    2. import java.awt.event.ActionEvent;
    3. import java.awt.event.ActionListener;
    4. import java.awt.event.WindowEvent;
    5. import java.io.File;
    6.  
    7. import javax.swing.JComboBox;
    8. import javax.swing.JDialog;
    9. import javax.swing.JFileChooser;
    10. import javax.swing.JLabel;
    11. import javax.swing.JOptionPane;
    12. import javax.swing.filechooser.FileFilter;
    13.  
    14. public class SaveDialog extends JDialog {
    15.     private JFileChooser fileChooser;
    16.     private JLabel lblName;
    17.     private JComboBox jbcName;
    18.     private SaveType saveType;
    19.  
    20.     SaveDialog(FileFilter filter, String path, String charSet) {
    21.         init(filter, path, charSet);
    22.     }
    23.  
    24.     SaveDialog(FileFilter filter) {
    25.         this(filter, null, "");
    26.     }
    27.  
    28.     void init(FileFilter filter, String path, String charSet) {
    29.         Container container = this.getContentPane();
    30.         container.setLayout(null);
    31.         if (path != null) {
    32.             fileChooser = new JFileChooser(path);
    33.         } else {
    34.             fileChooser = new JFileChooser();
    35.         }
    36.         fileChooser.setSize(550, 400);
    37.         fileChooser.setDialogType(JFileChooser.SAVE_DIALOG);
    38.         if (filter != null) {
    39.             fileChooser.setFileFilter(filter);
    40.         }
    41.         lblName = new JLabel("编码(E)");
    42.         lblName.setSize(60, 25);
    43.         lblName.setLocation(150, 390);
    44.         jbcName = new JComboBox();
    45.         jbcName.addItem("ANSI");
    46.         jbcName.addItem("Unicode");
    47.         jbcName.addItem("Unicode big endian");
    48.         jbcName.addItem("UTF-8");
    49.         jbcName.setSize(150, 25);
    50.         jbcName.setLocation(210, 390);
    51.         String encode = this.getCharset(charSet);
    52.         // 反向选中下拉框
    53.         jbcName.setSelectedItem(encode);
    54.         fileChooser.addActionListener(new ActionListener() {
    55.             @Override
    56.             public void actionPerformed(ActionEvent e) {
    57.                 String option = e.getSource().toString();
    58.                 if (option.contains("APPROVE_OPTION")) {
    59.                     File tempFile = fileChooser.getSelectedFile();//获取用户所选择的文件
    60.                     if(tempFile.exists()) {//如果文件已经存在则对是否保存文件进行确认
    61.                         if (JOptionPane.showConfirmDialog(SaveDialog.this, "文件已经存在，是否覆盖？",
    62.                                 "警告", JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION) {
    63.                             generateSaveType();//生成SaveType
    64.                             SaveDialog.this.dispose();
    65.                         } else {
    66.                             saveType = null;
    67.                         }
    68.                     }else {//如果文件不存在则直接生成SaveType
    69.                         SaveDialog.this.generateSaveType();//
    70.                         SaveDialog.this.dispose();
    71.                     }
    72.                 } else if (option.contains("CANCEL_OPTION")) {
    73.                     saveType = null;
    74.                     SaveDialog.this.dispose();
    75.                 }
    76.             }
    77.         });
    78.  
    79.         container.add(fileChooser);
    80.         container.add(lblName);
    81.         container.add(lblName);
    82.         container.add(jbcName);
    83.         this.setModal(true);// 设置为模态对话框
    84.         this.setSize(570, 470);
    85.         this.setLocationRelativeTo(null);
    86.         this.setTitle("另存为");
    87.         this.setVisible(true);
    88.     }
    89.  
    90.     private String getCharset(String name) {
    91.         String encode = "";
    92.         switch (name) {
    93.             case "GBK":
    94.                 encode = "ANSI";
    95.                 break;
    96.             case "UTF-16LE":
    97.                 encode = "Unicode";
    98.                 break;
    99.             case "UTF-16BE":
    100.                 encode = "Unicode big endian";
    101.                 break;
    102.             case "UTF-8":
    103.                 encode = "UTF-8";
    104.                 break;
    105.             default:
    106.                 encode = "ANSI";
    107.         }
    108.         return encode;
    109.     }
    110.  
    111.     public SaveType getSaveType() {
    112.         return saveType;
    113.     }
    114.  
    115.     protected void processWindowEvent(WindowEvent e) {
    116.         if (e.getID() == WindowEvent.WINDOW_CLOSING) {
    117.             saveType = null;
    118.             this.dispose();
    119.         }
    120.     }
    121.  
    122.     private void generateSaveType() {
    123.         saveType = new SaveType();
    124.         if ("文本文档".equals(fileChooser.getFileFilter().toString())) {// 如果用户选择了文本文件
    125.             saveType.setTxtFile(true);
    126.         } else {
    127.             saveType.setTxtFile(false);
    128.         }
    129.         saveType.setFile(fileChooser.getSelectedFile());
    130.         saveType.setEncode((String) jbcName.getSelectedItem());
    131.     }
    132.  
    133. }

    NoteBook.java

    1. public class NoteBook {
    2.     public static void main(String[] args) {
    3.         NoteBookFrame noteBookFrame = new NoteBookFrame();
    4.         noteBookFrame.setTitle("记事本--未命名");
    5.         noteBookFrame.setSize(400,300);
    6.         noteBookFrame.setLocationRelativeTo(null);
    7.         noteBookFrame.setVisible(true);
    8.     }
    9. }

    除阅读文章外，各位小伙伴还可以点击这里观看我在本站的视频课程学习Java！

    ​

  • 相关阅读:
    芯科蓝牙BG27开发笔记1-新建示例工程
    高性能云原生数据对象存储MinIO实战-中
    高等数学（第七版）同济大学 习题1-10 个人解答
    Python的requests库：解决文档缺失问题的策略与实践
    对自己LRU算法代码的优化
    超神之路 数据结构 2 —— Queue队列实现和循环队列和普通队列的性能比较
    【无标题】
    利用gpu加速神经网络算法,为什么用gpu 模型训练
    【云原生】云原生相关技术概念总结
    初识Java 10-1 集合
  • 原文地址：https://blog.csdn.net/shalimu/article/details/128150314