1. /*用java编写的一个类似Windows记事本的程序。现在已知有个bug，就是新打开的文件你没有修改，如果关闭文档的话，会有对话框提示你记事本已经改变，问你是否要保存，可是我并没有改变文档呀，就只是打开操作而已呀。*/
   
2. 
   
3. package notepad;
   
4. import java.io.*;
   
5. import java.awt.*;
   
6. import java.awt.event.*;
   
7. 
   
8. public class MyNotepad
   
9. {
   
10. private Frame f;
    
11. private MenuBar mbar;
    
12. private Menu m1;
    
13. private MenuItem exit;
    
14. private MenuItem create;
    
15. private MenuItem open;
    
16. private MenuItem save;
    
17. private MenuItem saveAs;
    
18. private TextArea ta;
    
19. 
    
20. private FileDialog saveDia,openDia,saveAsDia;
    
21. 
    
22. private File file = null;
    
23. private String dirPath = null;
    
24. private String fileName = null;
    
25. 
    
26. private String title = "MyNotepad - ";
    
27. private String defaultName = "无标题.txt";
    
28. 
    
29. private Dialog box;
    
30. private Panel subbox;
    
31. private Button OK;
    
32. private Button NO;
    
33. private Button back;
    
34. private Label lab;
    
35. 
    
36. private Dialog errorbox;
    
37. private Panel suberrorbox;
    
38. private Label lab2;
    
39. private Button OK2;
    
40. /*
    
41. 自定义信号量：
    
42. 如果textarea（文本域）内有更新，flag_update就设为ture；
    
43.   每次打开、新建、另保存操作后，就设为false；
    
44. 如果新建一个文档，flag_create 就设为ture；新建动作完成后设为false；
    
45. 如果打开一个文档，flag_open 就设为ture；打开动作完成后设为false；
    
46. 如果点击box内的取消（back），flag_back就设为ture；在判断完成后又将flag_设为false；
    
47. ... ...
    
48. */
    
49. private boolean flag_update = false;
    
50. private boolean flag_create = false;
    
51. private boolean flag_open = false;
    
52. private boolean flag_save = false;
    
53. private boolean flag_no = false;
    
54. private boolean flag_back = false;
    
55. 
    
56. MyNotepad()
    
57. {
    
58.   init();
    
59. }
    
60. 
    
61. void init()
    
62. {
    
63.   saveDia = new FileDialog(f,"保存",FileDialog.SAVE);
    
64.   saveAsDia = new FileDialog(f,"另存为",FileDialog.SAVE);
    
65.   openDia = new FileDialog(f,"打开",FileDialog.LOAD);
    
66. 
    
67.   f = new Frame(title + defaultName);
    
68.   f.setBounds(400,200,540,420);
    
69. 
    
70.   mbar = new MenuBar();
    
71. 
    
72.   m1 = new Menu("文件");
    
73. 
    
74.   exit = new MenuItem("退出");
    
75.   saveAs = new MenuItem("另存为");
    
76.   open = new MenuItem("打开   Ctrl+O");
    
77.   save = new MenuItem("保存   Ctrl+S");
    
78.   create = new MenuItem("新建   Ctrl+N");
    
79. 
    
80.   ta = new TextArea();
    
81. 
    
82.   f.setMenuBar(mbar);
    
83.   f.add(ta);
    
84. 
    
85.   mbar.add(m1);
    
86. 
    
87.   m1.add(create);
    
88.   m1.add(open);
    
89.   m1.add(save);
    
90.   m1.add(saveAs);
    
91.   m1.addSeparator();
    
92.   m1.add(exit);
    
93. 
    
94.   box = new Dialog(f,"MyNotepad",true);
    
95.   box.setBounds(480,300,250,150);
    
96.   box.setLayout(new GridLayout(2,1));
    
97. 
    
98.   subbox = new Panel(new FlowLayout());
    
99. 
    
100.   lab = new Label();
     
101.   OK = new Button("保存");
     
102.   NO = new Button("不保存");
     
103.   back = new Button("取消");
     
104.   
     
105.   box.add(lab);
     
106.   box.add(subbox);
     
107. 
     
108.   subbox.add(OK);
     
109.   subbox.add(NO);
     
110.   subbox.add(back);
     
111. 
     
112.   errorbox = new Dialog(f,"MyNotepad - 提示",true);
     
113.   errorbox.setLayout(new GridLayout(2,1));
     
114.   errorbox.setBounds(480,300,250,150);
     
115.   suberrorbox = new Panel(new FlowLayout());
     
116.   
     
117.   lab2 = new Label();
     
118.   OK2 = new Button("确定");
     
119.   
     
120.   errorbox.add(lab2);
     
121.   errorbox.add(suberrorbox);
     
122.   suberrorbox.add(OK2);
     
123. 
     
124.   noteEvent();//f里的监听器都封装在这里面；
     
125.   boxEvent();//对话框里的监听器都封装在这里面。
     
126. 
     
127.   f.setVisible(true);
     
128. }
     
129. 
     
130. //对话框监听器的封装函数
     
131. 
     
132. void boxEvent()
     
133. {
     
134.   //对关闭对话框监听；
     
135.   box.addWindowListener(new WindowAdapter()
     
136.   {
     
137.    public void windowClosing(WindowEvent e)
     
138.    {
     
139.     flag_back = true;
     
140.     box.setVisible(false);
     
141.    }
     
142.   });
     

复制代码

1. errorbox.addWindowListener(new WindowAdapter()
   
2.   {
   
3.    public void windowClosing(WindowEvent e)
   
4.    {
   
5.     errorbox.setVisible(false);
   
6.    }
   
7.   });
   
8. 
   
9. //对“取消”按钮监听
   
10. 
    
11.   back.addActionListener(new ActionListener()
    
12.   {
    
13.    public void actionPerformed(ActionEvent e)
    
14.    {
    
15.     flag_back = true;
    
16.     box.setVisible(false);
    
17.    }
    
18.   });
    
19. 
    
20.   back.addKeyListener(new KeyAdapter()
    
21.   {
    
22.    public void keyPressed(KeyEvent e)
    
23.    {
    
24.     if(e.getKeyCode()==KeyEvent.VK_ENTER)
    
25.     {
    
26.      flag_back = true;
    
27.      box.setVisible(false);
    
28.     }     
    
29.    }
    
30.   });
    
31. 
    
32. //对保存按钮监听；
    
33. 
    
34.   OK.addActionListener(new ActionListener()
    
35.   {
    
36.    public void actionPerformed(ActionEvent e)
    
37.    {
    
38.     flag_save = true;
    
39.     save(false);
    
40.    }
    
41.    
    
42.   });
    
43. 
    
44.   OK.addKeyListener(new KeyAdapter()
    
45.   {
    
46.    public void keyPressed(KeyEvent e)
    
47.    {
    
48.     if(e.getKeyCode()==KeyEvent.VK_ENTER)
    
49.     {
    
50.      flag_save = true;
    
51.      save(false);
    
52.     }   
    
53.    }
    
54.   });
    
55. 
    
56. //对errorbox里的“确定”按钮监听
    
57. 
    
58.   OK2.addActionListener(new ActionListener()
    
59.   {
    
60.    public void actionPerformed(ActionEvent e)
    
61.    {
    
62.     errorbox.setVisible(false);
    
63.    }
    
64.    
    
65.   });
    
66. 
    
67.   OK2.addKeyListener(new KeyAdapter()
    
68.   {
    
69.    public void keyPressed(KeyEvent e)
    
70.    {
    
71.     if(e.getKeyCode()==KeyEvent.VK_ENTER)
    
72.      errorbox.setVisible(false);
    
73.    }
    
74.   });
    
75. 
    
76. //对box里的不保存按钮监听；
    
77. 
    
78.   NO.addActionListener(new ActionListener()
    
79.   {
    
80.    public void actionPerformed(ActionEvent e)
    
81.    {
    
82.     box.setVisible(false);
    
83.     flag_no = true;
    
84.     if(flag_create == true || flag_open == true)
    
85.      return ;
    
86.     System.exit(0);
    
87.    }
    
88.   });
    
89. 
    
90.   NO.addKeyListener(new KeyAdapter()
    
91.   {
    
92.    public void keyPressed(KeyEvent e)
    
93.    {
    
94.     if(e.getKeyCode()==KeyEvent.VK_ENTER)
    
95.     {
    
96.      box.setVisible(false);
    
97.      flag_no = true;
    
98.      if(flag_create == true || flag_open == true)
    
99.       return ;
    
100.      System.exit(0);
     
101.     }
     
102.    }
     
103.   });
     
104. }
     
105. 
     
106. //f的事件监听封装函数；
     
107. 
     
108. void noteEvent()
     
109. {
     
110. 
     
111. //对关闭f监听；
     
112.   f.addWindowListener(new WindowAdapter()
     
113.   {
     
114.    public void windowClosing(WindowEvent e)
     
115.    {
     
116.     if(flag_update == true)
     
117.     {
     
118.      message();
     
119.      if(flag_back ==true)
     
120.      {
     
121.       flag_back = false;
     
122.       box.setVisible(false);
     
123.       return ;
     
124.      }
     
125.      if(flag_no == true)
     
126.      {
     
127.       flag_no = false;
     
128.       System.exit(0);
     
129.      }
     
130.      if(flag_save == true)
     
131.      {
     
132.       flag_save = false;
     
133.       if(fileName==null || dirPath==null)
     
134.       {
     
135.        return ;
     
136.       }
     
137.      }
     
138.     }
     
139.     System.exit(0);
     
140.    }
     
141.   });
     
142. 
     
143. //对菜单里的“退出”监听
     
144. 
     
145.   exit.addActionListener(new ActionListener()
     
146.   {
     
147.    public void actionPerformed(ActionEvent e)
     
148.    {
     
149.     if(flag_update == true)
     
150.     {
     
151.      message();
     
152.      if(flag_back ==true)
     
153.      {
     
154.       flag_back = false;
     
155.       return ;
     
156.      }
     
157.      if(flag_no == true)
     
158.      {
     
159.       flag_no = false;
     
160.       System.exit(0);
     
161.      }
     
162.      if(flag_save == true)
     
163.      {
     
164.       flag_save = false;
     
165.       if(fileName==null || dirPath==null)
     
166.       {
     
167.        return ;
     
168.       }
     
169.      }
     
170.     }
     
171.     System.exit(0);
     
172.    }
     
173.   });
     
174. 
     
175. //对文本域进行改动监听；
     
176. 
     
177.   ta.addTextListener(new TextListener()
     
178.   {
     
179.    public void textValueChanged(TextEvent e)
     
180.    {
     
181.     flag_update = true;
     
182.    }
     
183.   });
     
184. 
     
185. //下面的都是对菜单里的item进行监听。并且设置了快捷键监听；
     
186. 
     
187.   ta.addKeyListener(new KeyAdapter()
     
188.   {
     
189.    public void keyPressed(KeyEvent e)
     
190.    {
     
191.     int key = e.getKeyCode();
     
192.     if(e.isControlDown() && key == KeyEvent.VK_N)
     
193.     {
     
194.      flag_create = true;
     
195.      if(flag_update == true)
     
196.      {
     
197.       message();
     
198.       if(flag_back == true)
     
199.       {
     
200.        flag_back = false;
     
201.        return ;
     
202.       }
     
203.       if(flag_no == true)
     
204.       {
     
205.        flag_no = false;
     
206.        create();
     
207.        return ;
     
208.       }
     
209.       if(flag_save == true)
     
210.       {
     
211.        flag_save = false;
     
212.        if(fileName==null || dirPath==null)
     
213.        {
     
214.         return ;
     
215.        }
     
216.       }
     
217.      }
     
218.      create();
     
219.     }
     
220.    }
     
221.   });
     

复制代码

1.   ta.addKeyListener(new KeyAdapter()
   
2.   {
   
3.    public void keyPressed(KeyEvent e)
   
4.    {
   
5.     int key = e.getKeyCode();
   
6.     if(e.isControlDown() && key==KeyEvent.VK_O)
   
7.     {
   
8.      flag_open = true;
   
9.      if(flag_update == true)
   
10.      {
    
11.       message();
    
12.       if(flag_back == true)
    
13.       {
    
14.        flag_back = false;
    
15.        return ;
    
16.       }
    
17.       if(flag_no == true)
    
18.       {
    
19.        flag_no = false;
    
20.        open();//调用已经封装好的打开操作；
    
21. 
    
22.         //以下的message、save、saveAs、create等都是已经自定义封装好的。可以直接调用；
    
23.        return ;
    
24.       }
    
25.       if(flag_save == true)
    
26.       {
    
27.        flag_save = false;
    
28.        if(fileName==null || dirPath==null)
    
29.        {
    
30.         return ;
    
31.        }
    
32.       }
    
33.      }  
    
34.      open();
    
35.     }   
    
36.    }
    
37.   });
    
38. 
    
39.   ta.addKeyListener(new KeyAdapter()
    
40.   {
    
41.    public void keyPressed(KeyEvent e)
    
42.    {
    
43.     int key = e.getKeyCode();
    
44.     if(e.isControlDown() && key==KeyEvent.VK_S)
    
45.     {
    
46.      save(true);
    
47.     }
    
48.    }
    
49.   });
    
50. 
    
51.   create.addActionListener(new ActionListener()
    
52.   {
    
53.    public void actionPerformed(ActionEvent e)
    
54.    {
    
55.     flag_create = true;
    
56.     if(flag_update == true)
    
57.     {
    
58.      message();
    
59.      if(flag_back == true)
    
60.      {
    
61.       flag_back = false;
    
62.       return ;
    
63.      }
    
64.      if(flag_no == true)
    
65.      {
    
66.       flag_no = false;
    
67.       create();
    
68.       return ;
    
69.      }
    
70.      if(flag_save == true)
    
71.      {
    
72.       flag_save = false;
    
73.       if(fileName==null || dirPath==null)
    
74.       {
    
75.        return ;
    
76.       }
    
77.      }
    
78.     }
    
79.     create();
    
80.    }
    
81.   });
    
82. 
    
83.   open.addActionListener(new ActionListener()
    
84.   {
    
85.    public void actionPerformed(ActionEvent e)
    
86.    {
    
87.     flag_open = true;
    
88.     if(flag_update==true)
    
89.     {
    
90.      message();
    
91.      if(flag_back == true)
    
92.      {
    
93.       flag_back = false;
    
94.       return ;
    
95.      }
    
96.      if(flag_no == true)
    
97.      {
    
98.       flag_no = false;
    
99.       open();
    
100.       return ;
     
101.      }
     
102.      if(flag_save == true)
     
103.      {
     
104.       flag_save = false;
     
105.       if(fileName==null || dirPath==null)
     
106.       {
     
107.        return ;
     
108.       }
     
109.      }
     
110.     }
     
111.     open();
     
112.    }
     
113.   });
     
114. 
     
115.   save.addActionListener(new ActionListener()
     
116.   {
     
117.    public void actionPerformed(ActionEvent e)
     
118.    {
     
119.     save(true);
     
120.    }
     
121.   });
     
122. 
     
123.   saveAs.addActionListener(new ActionListener()
     
124.   {
     
125.    public void actionPerformed(ActionEvent e)
     
126.    {
     
127.     saveAs();
     
128.    }
     
129.    
     
130.   });
     
131. }
     
132. 
     
133. //对保存操作进行封装；
     
134. 
     
135. void save(boolean mode)
     
136. {
     
137.   if(file==null)
     
138.   {
     
139.    saveDia.setVisible(true);
     
140. 
     
141.    dirPath = saveDia.getDirectory();
     
142.    fileName = saveDia.getFile();
     
143. 
     
144.    if(fileName==null || dirPath==null)
     
145.    {
     
146.     f.setTitle(title + defaultName);
     
147. 
     
148.     if(mode)
     
149.      return;
     
150.     else
     
151.     {
     
152.      box.setVisible(false);
     
153.      return;
     
154.     }
     
155.    }
     
156.    
     
157.    if(fileName.lastIndexOf(".")==-1)
     
158.     fileName = fileName + ".txt";
     
159. 
     
160.    f.setTitle(title + fileName);
     
161.    
     
162.    file = new File(dirPath,fileName);
     
163.   }
     
164. 
     
165.   BufferedWriter bfw = null;
     
166. 
     
167.   try
     
168.   {
     
169.    bfw = new BufferedWriter(new FileWriter(file));
     
170.    String text = ta.getText();
     
171.    bfw.write(text);
     
172.   }
     
173.   catch (IOException e1)
     
174.   {
     
175.    throw new RuntimeException("文件保存失败");
     
176.   }
     
177.   finally
     
178.   {
     
179.    if(bfw!=null)
     
180.    {
     
181.     try
     
182.     {
     
183.      bfw.close();
     
184.     }
     
185.     catch (IOException e2)
     
186.     {
     
187.      throw new RuntimeException("资源关闭失败");
     
188.     }
     
189.    }
     
190.   }
     
191. 
     
192.   if(!mode)
     
193.    box.setVisible(false);
     
194. 
     
195.   flag_update = false ;
     
196.   flag_create = false ;
     
197.   flag_open = false ;
     
198.   flag_save = false ;
     
199. }
     
200. 
     
201. void create()
     
202. {
     
203.   file = null;
     
204.   fileName = null;
     
205.   f.setTitle(title + defaultName);
     
206.   ta.setText("");
     
207. 
     
208.   flag_update = false ;
     
209.   flag_create = false ;
     
210.   flag_open = false ;
     
211.   flag_save = false ;
     
212. }
     
213. 
     
214. //对另存为操作进行封装；
     
215. 
     
216. void saveAs()
     
217. {
     
218.   saveAsDia.setVisible(true);
     
219. 
     
220.   dirPath = saveAsDia.getDirectory();
     
221.   fileName = saveAsDia.getFile();
     
222. 
     
223.   if(fileName==null || dirPath==null)
     
224.    return ;
     
225. 
     
226.   if(fileName.lastIndexOf(".")==-1)
     
227.     fileName = fileName + ".txt";
     
228. 
     
229.   f.setTitle(title + fileName);
     
230.    
     
231.   file = new File(dirPath,fileName);
     
232. 
     
233.   BufferedWriter bfw = null;
     
234.   try
     
235.   {
     
236.    bfw = new BufferedWriter(new FileWriter(file));
     
237.    String text = ta.getText();
     
238.    bfw.write(text);
     
239.   }
     
240.   catch (IOException e1)
     
241.   {
     
242.    throw new RuntimeException("文件保存失败");
     
243.   }
     
244.   finally
     
245.   {
     
246.    if(bfw!=null)
     
247.    {
     
248.     try
     
249.     {
     
250.      bfw.close();
     
251.     }
     
252.     catch (IOException e2)
     
253.     {
     
254.      throw new RuntimeException("资源关闭失败");
     
255.     }
     
256.    }
     
257.   }
     
258.   flag_update = false ;
     
259.   flag_create = false ;
     
260.   flag_open = false ;
     
261.   flag_save = false ;
     
262. }
     
263. 
     
264. //对打开操作进行封装；
     
265. 
     
266. void open()
     
267. {
     
268.   openDia.setVisible(true);
     
269. 
     
270.   dirPath = openDia.getDirectory();
     
271.   fileName = openDia.getFile();
     
272. 
     
273.   if(fileName==null || dirPath==null)
     
274.    return ;
     
275. 
     
276.   file = new File(dirPath,fileName);
     
277. 
     
278.   if(!file.exists())
     
279.   {
     
280.    errorBox();
     
281.    return ;
     
282.   }  
     
283. 
     
284.   f.setTitle(title + fileName);
     
285. 
     
286.   ta.setText("");
     
287. 
     
288.   BufferedReader bfr = null;
     
289.   try
     
290.   {
     
291.    bfr = new BufferedReader(
     
292.     new InputStreamReader(new FileInputStream(file),"GB2312"));
     
293.    String line = null;
     
294.    while((line = bfr.readLine())!= null)
     
295.    {
     
296.     ta.append(line+"\r\n");
     
297.    }
     
298.   }
     
299.   catch (IOException ioe1)
     
300.   {
     
301.    throw new RuntimeException("文件打开失败");
     
302.   }
     
303.   finally
     
304.   {
     
305.    if(bfr!=null)
     
306.    {
     
307.     try
     
308.     {
     
309.      bfr.close();
     
310.     }
     
311.     catch (IOException ioe2)
     
312.     {
     
313.      throw new RuntimeException("资源关闭失败");
     
314.     }
     
315.    }
     
316.   }
     
317. 
     
318.   flag_open = false ;
     
319.   flag_update = false ;
     
320.   flag_create = false ;
     
321.   flag_save = false ;
     
322. }
     
323. 
     
324. //封装了对话框；
     
325. 
     
326. void message()
     
327. {
     
328.   String text = null;
     
329.   if(fileName == null)
     
330.    text = "文件 无标题.txt 已经改变，需要保存吗？";
     
331.   else
     
332.    text = "文件 " + fileName + " 已经改变，需要保存吗？";
     
333.   lab.setText(text);
     
334.   box.setVisible(true);
     
335. }
     
336. //封装了提示框
     
337. void errorBox()
     
338. {
     
339.   lab2.setText("你要找的文件"+fileName+"没有找到！");
     
340.   errorbox.setVisible(true);
     
341. }
     
342. 
     
343. //主函数调用；
     
344. public static void main(String[] args)
     
345. {
     
346.   new MyNotepad();
     
347. }
     
348. }

复制代码

自己顶一下