写自己的MEditor之三：添加菜单

    菜单栏(JMenuBar)包含多个根菜单(JMenu),每个根菜单下可以有零到多个菜单项(JMenuItem)。

    结构图如下：

    ********************************************************

    * ---- JMenu -------- JMenu --------JMenu              *

    *        |              |             |                *

    *        |-JMenuItem    |-JMenuItem   |-JMenuItem      *

    *        |                                             *

    *        |-JMenuItem                                   *

    *        |    |                                        *

    *        |    |-JMenuItem                              *

    *        |                                             *

    *        |-JMenuItem                                   *

    **********************  JMenuBar ***********************

 

　　每个菜单项都对应着一项或多项功能，要生成这么多菜单项，完成的功能也很复杂。如果管理好这么多功能，控制好程序结构，就需要工厂方法来帮忙了。工厂方法的提出目的之一，是为了简化客户端的代码复杂度。试想这么多的菜单项，要一个一个new，实在是一件痛苦的事情。脱离苦海的方法之一，便是封装。将实现细节隐藏在工厂车间里，生产出来的产品直接使用便是。

 

　　这里将每个根菜单视作产品的话，则只需在客户端程序中调用工厂方法生产几个根菜单即可。大致UML关系如下：

 

　　客户端代码只需对MEditor.java稍作修改，如下：

1. public class MEditor { 
2.  
3.     ... 
4.     ... 
5.     /** 
6.      * 编辑器菜单栏 
7.      */ 
8.     private EditorMenu fileMenu; 
9.  
10.     public void createWindow() { 
11.     
12. ... 
13.      // 利用工厂方法创建根菜单 
14.      MenuFactory fileMenuFactory = new FileMenuFactory(); 
15.      fileMenu = fileMenuFactory.getMenuInstance(); 
16.  
17.      // 将根菜单放入菜单栏中， 
18.      JMenuBar menuBar = new JMenuBar(); 
19.      menuBar.add((JMenu) fileMenu); 
20.      frame.setJMenuBar(menuBar); 
21.      ... 
22.     } 
23. }  

　　生产根菜单的抽象工厂(MenuFactory.java)代码如下：

1. /** 
2.  * 用于描述根菜单工厂的接口 
3.  *  
4.  * @author mitume 
5.  * @version MEditor v1.0 
6.  */ 
7. public interface MenuFactory { 
8.      
9.     /** 
10.      * 取得根菜单实例 
11.      */ 
12.     public EditorMenu getMenuInstance(); 
13. } 

    生产根菜单的具体工厂(FileMenuFactory.java)代码如下：

1. /** 
2.  * File根菜单的具体生产工厂 
3.  *  
4.  * @author mitume 
5.  * @version MEditor v1.0 
6.  */ 
7. public class FileMenuFactory implements MenuFactory { 
8.  
9.     /** 
10.      * 取得文件根菜单的实例 
11.      */ 
12.     @Override 
13.     public FileMenu getMenuInstance() { 
14.         return FileMenu.getInstance(); 
15.     } 
16. } 

　　抽象的工厂产品(EditorMenu.java)代码如下：

1. /** 
2.  * 用于描述编辑器根菜单的接口 
3.  *  
4.  * @author mitume 
5.  * @version MEditor v1.0 
6.  */ 
7. public interface EditorMenu{ 
8.  
9.     // 待添加以描述行为  
10. } 

　　具体的工厂产品(FileMenu.java)代码如下：

1. /** 
2.  * 根菜单类(File) 
3.  *  
4.  * @author mitume 
5.  * @version MEditor v1.0 
6.  */ 
7. public class FileMenu extends JMenu implements EditorMenu{ 
8.      
9.     /* 
10.      * 取得FileMenu的唯一实例 
11.      */ 
12.     static public FileMenu getInstance() { 
13.  
14.         if (fileMenu != null) { 
15.             return fileMenu; 
16.         } 
17.         else { 
18.             genEditorMenu(); 
19.             return fileMenu; 
20.         } 
21.     } 
22.      
23.     /* 
24.      * 创建菜单 
25.      */ 
26.     static private void genEditorMenu() { 
27.          
28.                 // 创建自身实例 
29.         fileMenu = new FileMenu("File"); 
30.         fileMenu.setMnemonic('F'); 
31.          
32.                 // 加入新建菜单项 
33.         menuFileNew = new JMenuItem("New", 'N'); 
34.         fileMenu.add(menuFileNew); 
35.     } 
36.      
37.     /** 
38.      * FileMenu类的唯一实例 
39.      */ 
40.     static private FileMenu fileMenu; 
41.      
42.     /** 
43.      * 菜单项<新建> 
44.      */ 
45.     static private JMenuItem menuFileNew = null; 
46.          
47.     /** 
48.      * 构造方法(私有) 
49.      * @param menuName 
50.      */ 
51.     private FileMenu(String menuName) { 
52.         super(menuName); 
53.     } 
54. } 

　　这里的FileMenu写的很不好看，尤其是菜单项的添加，显得笨拙。先写到这里吧，以后想起再修改。

　　设想中，以后为用户提供一个根菜单。用户可以对其下进行编辑，生成自己的菜单项。或是将整个根菜单做成插件，动态添加。
纯属遐想，还不知道如何实现。Mark一下先。

　　最后上今天的效果图，新建菜单项出来了。

转载于:https://blog.51cto.com/mitume/617201