动态生成菜单和java反射机制的使用

动态菜单----动态生成菜单和java反射机制的使用

标签： javaclass数据库解决方案设计

2015-08-21 16:45 1416人阅读 评论(0) 收藏 举报

分类：

Java（3）

作者同类文章 X

版权声明：本文为博主原创文章，未经博主允许不得转载。

上一篇博文中介绍了Java的反射机制的原理和基本功能，读后肯定对反射机制有一定的了解，本篇博文将以我的项目要求为例子，讲述动态菜单的生成和java反射机制的使用。

任务要求：所有的菜单项都从数据库中取得，从数据库中取得的只是一个字符串，程序区分菜单，和一级菜单，二级菜单的多级菜单，以后若想增加或减少菜单项，只需更改数据库表即可（数据库表自己设计），生成好菜单后，点击菜单项弹出对应的模块。先看下面的具体的需求和操作要求吧！

1、菜单权限设置

     1、如果需要对不同的用户采取权限设置，可以建立相关的数据库表，进行设置，程序可以提取数据，自动生成设置有权限的菜单。（本例子中代码有从权限数据库表中取 得相关用户的菜单权限）

2、菜单可见和不可见。

3、菜单可用和不可用（灰色状态）

 2、    自动生成菜单

1、数据库表中所包含的字段有：菜单编号，菜单名字，菜单所对应类名字，父菜单编号，菜单类型。

2、若用户想增加或减少菜单，只需改变数据库表，而程序不需要更改。

  3、    多级菜单的生成

1、生成多级菜单只需更改数据库表，在数据库表中填写清楚菜单类型，和子菜单编号，父菜单的编号。

2、多级菜单的寻找方案为递归寻找。

  4、    java反射机制动态调用类

             1、数据库表中，字段：菜单类名字保存的是相对应的菜单项对应的类名字。

      2、点击菜单项，程序能够动态的调用相应的类，生成界面参见图3-1 微易码信息管理系统 – 主界面菜单。 

 5、数据库表的设计：

1、菜单中有JMen类型，类似于记事本中“文件”、“编辑”、“格式”等等；

2、菜单中有JMenuItem类型，类似于记事本中的文件下的“新建”、“打开”、“保存”等等；

3、数据库表中要存储有菜单项中对应的类名（方便使用反射机制）；

4、数据库表中还包含分割线“-”，以区分不同类别的菜单项；

根据要求，数据库以Access为例，我对数据库表的设计是这样的，字段有：

Menu_Id（菜单编号 ，短文本）、Menu_Name(菜单名，短文本)、Class_Name(菜单项对应的类名，短文本)、Father_Id(父菜单的编号、短文本)、Menu_Type(菜单类型、数字)如下图：

注意数据库表的设计，数据库表是怎么设计的，就几乎决定了你的程序的设计思路，因为数据是从数据库中取得的。主菜单的Fatner_Id编号为"0000" ，Menu_Type为0；分割线的Menu_Type为1，工具栏的菜单项Father_Id为"0000",Menu_Type为2（工具栏菜单上表中未出现）。

说了这么多，还是看图清楚，其实就是要完成这样的结果：

下面的这张就是点击菜单项后弹出对应的窗口，

想要看完成这个项目的代码就接着往下看吧，直接上代码了：

连接数据库代码：

[html] view plain copy

print ?

1. import java.sql.Connection;  
2. import java.sql.DriverManager;  
3. import java.sql.ResultSet;  
4. import java.sql.SQLException;  
5. import java.sql.Statement;  
6.   
7. /**  
8.  * 此类供调用者完成对数据库的链接，并对数据进行操作的工作  
9.  * @author Administrator  
10.  *  
11.  */  
12. public class MECDatabase {  
13.       
14.     private int databaseType;   /*要链接的数据库类型*/  
15.   
16.     private static final String[] DB_DRIVER = {"oracle.jdbc.OracleDriver",      /*链接数据库的驱动*/  
17.                                                 "sun.jdbc.odbc.JdbcOdbcDriver",  
18.                                                 "com.mysql.jdbc.Driver"};  
19.       
20.     private static final String[] URL = {"jdbc:oracle:thin:@","jdbc:odbc:","jdbc:mysql://"};    /*链接数据库的ＵＲＬ*/  
21.       
22.     private static final int ORACLE = 0;    /*数据库类型*/  
23.     private static final int ACCESS = 1;  
24.     private static final int MYSQL = 2;  
25.       
26.     private Statement stmt;  
27.     private Connection con;  
28.     private ResultSet rst;  
29.   
30.     /**  
31.      * 带参的构造方法  
32.      * @param databaseType 传入要链接的数据库类型(int 类型)  
33.      *                      0表示链接Oracle数据库  
34.      *                      1表示链接Access数据库  
35.      *                      2表示链接MySql数据库  
36.      */  
37.     public MECDatabase(int databaseType){  
38.           
39.         this.databaseType = databaseType;  
40.         stmt = null;  
41.         con = null;  
42.         rst = null;  
43.     }  
44.       
45.     /**  
46.      * 获得数据库类型  
47.      * @return 返回数据库类型  
48.      */  
49.     private int getDatabaseType() {  
50.         return databaseType;  
51.     }  
52.   
53.     /**  
54.      * 链接不需要IP和端口号的数据库  
55.      * @param databaseName 数据源名称  
56.      * @throws Exception    链接数据库时遇到的异常  
57.      */  
58.     public void connection(String databaseName) throws Exception{  
59.           
60.         try {  
61.                 Class.forName(DB_DRIVER[ACCESS]);  
62.                 con = DriverManager.getConnection(URL[ACCESS]+databaseName);  
63.                 stmt = con.createStatement();  
64.         } catch (ClassNotFoundException e) {  
65.             throw new Exception("错误：" + e.getMessage() + "\n" +  
66.                     "类：MECDatabase\n方法：public void connection() throws Exception\n\n" +  
67.                     "请咨询微易码开发技术人员，解决这个问题！");  
68.           
69.         }  
70.     }  
71.       
72.     /**  
73.      * 链接数据库  
74.      * @param hostIp        主机IP地址  
75.      * @param port          端口号  
76.      * @param databaseName  数据源名称  
77.      * @param userName      用户名  
78.      * @param password      密码  
79.      * @throws Exception    连接数据库是遇到的异常  
80.      */  
81.     public void connection(String hostIp,int port,String databaseName,String userName,String password) throws Exception {  
82.           
83.           
84.         try {  
85.                 if(this.getDatabaseType() == ORACLE){  
86.                     Class.forName(DB_DRIVER[ORACLE]);  
87.                     con = DriverManager.getConnection(URL[ORACLE]+hostIp+":"+port+"/"+databaseName,userName,password);  
88.               
89.                 }else{  
90.                     Class.forName(DB_DRIVER[MYSQL]);  
91.                     con = DriverManager.getConnection(URL[MYSQL]+hostIp+":"+port+"/"+databaseName,userName,password);  
92.                 }  
93.                 stmt = con.createStatement();  
94.                   
95.           
96.         } catch (ClassNotFoundException e1) {  
97.             throw new Exception("错误：" + e1.getMessage() + "\n" +  
98.                     "类：MECDatabase\n方法：public void connection() throws Exception\n\n" +  
99.                     "请咨询微易码开发技术人员，解决这个问题！");  
100.               
101.         } catch (SQLException e2) {  
102.             throw new Exception("错误：" + e2.getMessage() + "\n" +  
103.                     "类：MECDatabase\n方法：public void connection() throws Exception\n\n" +  
104.                     "请咨询微易码开发技术人员，解决这个问题！");      
105.         }  
106.     }     
107.       
108.     /**  
109.      * 关闭与当前数据库的链接  
110.      * @throws Exception 关闭数据库链接时遇到的异常  
111.      */  
112.     public void disConnection()throws Exception{  
113.           
114.         try  
115.         {  
116.             if(rst != null)  
117.                 rst.close();  
118.             if(stmt != null)  
119.                 stmt.close();  
120.             if(con != null)  
121.                 con.close();  
122.         }catch(SQLException sqle)  
123.         {  
124.             throw new Exception("错误：" + sqle.getMessage() + "\n" +  
125.                     "类：MECDatabase\n方法：public void disConnection() throws Exception\n");  
126.         }  
127.     }  
128.       
129.     /**  
130.      * 执行SQL语句，doSql方法只能完成查询功能  
131.      * @param sqlSwing 传入的SQL语句  
132.      * @return 返回查询的对象  
133.      * @throws Exception 执行SQL语句时遇到的异常  
134.      */  
135.     public ResultSet doSql(String sql)throws Exception{  
136.           
137.         if(stmt != null){  
138.             try{  
139.                 rst = stmt.executeQuery(sql);  
140.             }catch(SQLException sqlE){  
141.                   
142.                 sqlE.printStackTrace();  
143.                 throw new Exception("错误：" + sqlE.getMessage() + "\n" +  
144.                         "类：MECDatabase\n" +  
145.                         "方法：public ResultSet doSql(String SQL) throws Exception\n");  
146.             }  
147.         }  
148.         return rst;  
149.     }  
150.       
151.     /**  
152.      * 执行SQL语句，doSql方法只能完成查询功能,并将查询的内部指针最后指向首位  
153.      * @param sqlSwing 传入的SQL语句  
154.      * @return 返回查询的对象  
155.      * @throws Exception 执行SQL语句时遇到的异常  
156.      */  
157.     public ResultSet select(String sql)throws Exception{  
158.         if(stmt != null){  
159.             try{  
160.                 //默认的ResultSet对象不可更新，仅有一个向前移动的光标，因此只能迭代它一次，并且只能按从第一行到  
161.                 //最后一行的顺序进行，可以生成可以滚动的/或可更新的ResultSet对象，以下这句话就是实现该功能，  
162.                 //不然主程序中result的执行就会出错  
163.                 stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);  
164.                 rst = stmt.executeQuery(sql);  
165.             }catch(SQLException sqlE){  
166.                   
167.                 throw new Exception("错误：" + sqlE.getMessage() + "\n" +  
168.                         "类：MECDatabase\n" +  
169.                         "方法：public ResultSet select(String SQL) throws Exception\n");  
170.             }  
171.         }  
172.         return rst;  
173.     }  
174.     /**  
175.      * 执行SQL语句，upDate方法可以完成创建，修改，插入，删除等功能  
176.      * @param sqlSwing 传入的SQL语句  
177.      * @return 返回该操作是否成功  
178.      * @throws Exception 执行SQL语句时遇到的异常  
179.      */  
180.     public boolean update(String sql)throws Exception{  
181.           
182.         boolean flag = false;  
183.           
184.         if(stmt != null){  
185.             try{  
186.                 flag = stmt.execute(sql);  
187.             }catch(SQLException sqlE){  
188.                   
189.                 throw new Exception("错误：" + sqlE.getMessage() + "\n" +  
190.                         "类：MECDatabase\n" +  
191.                         "方法：public ResultSet update(String SQL) throws Exception\n");  
192.             }  
193.         }  
194.         return flag;  
195.     }  
196.   
197. }  

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

/**
 * 此类供调用者完成对数据库的链接，并对数据进行操作的工作
 * @author Administrator
 *
 */
public class MECDatabase {
	
	private int databaseType;	/*要链接的数据库类型*/

	private static final String[] DB_DRIVER = {"oracle.jdbc.OracleDriver",		/*链接数据库的驱动*/
												"sun.jdbc.odbc.JdbcOdbcDriver",
												"com.mysql.jdbc.Driver"};
	
	private static final String[] URL = {"jdbc:oracle:thin:@","jdbc:odbc:","jdbc:mysql://"};	/*链接数据库的ＵＲＬ*/
	
	private static final int ORACLE = 0;	/*数据库类型*/
	private static final int ACCESS = 1;
	private static final int MYSQL = 2;
	
	private Statement stmt;
	private Connection con;
	private ResultSet rst;

	/**
	 * 带参的构造方法
	 * @param databaseType 传入要链接的数据库类型(int 类型)
	 * 						0表示链接Oracle数据库
	 * 						1表示链接Access数据库
	 * 						2表示链接MySql数据库
	 */
	public MECDatabase(int databaseType){
		
		this.databaseType = databaseType;
		stmt = null;
		con = null;
		rst = null;
	}
	
	/**
	 * 获得数据库类型
	 * @return 返回数据库类型
	 */
	private int getDatabaseType() {
		return databaseType;
	}

	/**
	 * 链接不需要IP和端口号的数据库
	 * @param databaseName 数据源名称
	 * @throws Exception	链接数据库时遇到的异常
	 */
	public void connection(String databaseName) throws Exception{
		
		try {
				Class.forName(DB_DRIVER[ACCESS]);
				con = DriverManager.getConnection(URL[ACCESS]+databaseName);
				stmt = con.createStatement();
		} catch (ClassNotFoundException e) {
			throw new Exception("错误：" + e.getMessage() + "\n" +
					"类：MECDatabase\n方法：public void connection() throws Exception\n\n" +
					"请咨询微易码开发技术人员，解决这个问题！");
		
		}
	}
	
	/**
	 * 链接数据库
	 * @param hostIp 		主机IP地址
	 * @param port			端口号
	 * @param databaseName	数据源名称
	 * @param userName		用户名
	 * @param password		密码
	 * @throws Exception	连接数据库是遇到的异常
	 */
	public void connection(String hostIp,int port,String databaseName,String userName,String password) throws Exception {
		
		
		try {
				if(this.getDatabaseType() == ORACLE){
					Class.forName(DB_DRIVER[ORACLE]);
					con = DriverManager.getConnection(URL[ORACLE]+hostIp+":"+port+"/"+databaseName,userName,password);
			
				}else{
					Class.forName(DB_DRIVER[MYSQL]);
					con = DriverManager.getConnection(URL[MYSQL]+hostIp+":"+port+"/"+databaseName,userName,password);
				}
				stmt = con.createStatement();
				
		
		} catch (ClassNotFoundException e1) {
			throw new Exception("错误：" + e1.getMessage() + "\n" +
					"类：MECDatabase\n方法：public void connection() throws Exception\n\n" +
					"请咨询微易码开发技术人员，解决这个问题！");
			
		} catch (SQLException e2) {
			throw new Exception("错误：" + e2.getMessage() + "\n" +
					"类：MECDatabase\n方法：public void connection() throws Exception\n\n" +
					"请咨询微易码开发技术人员，解决这个问题！");	
		}
	}	
	
	/**
	 * 关闭与当前数据库的链接
	 * @throws Exception 关闭数据库链接时遇到的异常
	 */
	public void disConnection()throws Exception{
		
		try
		{
			if(rst != null)
				rst.close();
			if(stmt != null)
				stmt.close();
			if(con != null)
				con.close();
		}catch(SQLException sqle)
		{
			throw new Exception("错误：" + sqle.getMessage() + "\n" +
					"类：MECDatabase\n方法：public void disConnection() throws Exception\n");
		}
	}
	
	/**
	 * 执行SQL语句，doSql方法只能完成查询功能
	 * @param sqlSwing 传入的SQL语句
	 * @return 返回查询的对象
	 * @throws Exception 执行SQL语句时遇到的异常
	 */
	public ResultSet doSql(String sql)throws Exception{
		
		if(stmt != null){
			try{
				rst = stmt.executeQuery(sql);
			}catch(SQLException sqlE){
				
				sqlE.printStackTrace();
				throw new Exception("错误：" + sqlE.getMessage() + "\n" +
						"类：MECDatabase\n" +
						"方法：public ResultSet doSql(String SQL) throws Exception\n");
			}
		}
		return rst;
	}
	
	/**
	 * 执行SQL语句，doSql方法只能完成查询功能,并将查询的内部指针最后指向首位
	 * @param sqlSwing 传入的SQL语句
	 * @return 返回查询的对象
	 * @throws Exception 执行SQL语句时遇到的异常
	 */
	public ResultSet select(String sql)throws Exception{
		if(stmt != null){
			try{
				//默认的ResultSet对象不可更新，仅有一个向前移动的光标，因此只能迭代它一次，并且只能按从第一行到
				//最后一行的顺序进行，可以生成可以滚动的/或可更新的ResultSet对象，以下这句话就是实现该功能，
				//不然主程序中result的执行就会出错
				stmt = con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_UPDATABLE);
				rst = stmt.executeQuery(sql);
			}catch(SQLException sqlE){
				
				throw new Exception("错误：" + sqlE.getMessage() + "\n" +
						"类：MECDatabase\n" +
						"方法：public ResultSet select(String SQL) throws Exception\n");
			}
		}
		return rst;
	}
	/**
	 * 执行SQL语句，upDate方法可以完成创建，修改，插入，删除等功能
	 * @param sqlSwing 传入的SQL语句
	 * @return 返回该操作是否成功
	 * @throws Exception 执行SQL语句时遇到的异常
	 */
	public boolean update(String sql)throws Exception{
		
		boolean flag = false;
		
		if(stmt != null){
			try{
				flag = stmt.execute(sql);
			}catch(SQLException sqlE){
				
				throw new Exception("错误：" + sqlE.getMessage() + "\n" +
						"类：MECDatabase\n" +
						"方法：public ResultSet update(String SQL) throws Exception\n");
			}
		}
		return flag;
	}

}

DestopPane类：

[java] view plain copy

print ?

1. import java.awt.Graphics;  
2. import java.awt.Image;  
3.   
4. import javax.swing.ImageIcon;  
5. import javax.swing.JDesktopPane;  
6.   
7. public class DesktopPane extends JDesktopPane   
8. {  
9.     private static final long serialVersionUID = 1L;  
10.     private ImageIcon ico = new ImageIcon("E:\\java练习\\9353.jpg");  
11.       
12.     public DesktopPane()  
13.     {  
14.         this(0,0);  
15.     }  
16.       
17.     public DesktopPane(int width, int heght)  
18.     {  
19.         getimage(width,heght);  
20.     }  
21.       
22.     public void getimage(int width, int heght)  
23.     {  
24.         ico.setImage(ico.getImage().getScaledInstance(width,heght,Image.SCALE_DEFAULT));  
25.     }  
26.       
27.     public void paintComponent(Graphics g)  
28.     {  
29.          g.drawImage(ico.getImage(),0,0,this);  
30.     }  
31. }  

import java.awt.Graphics;
import java.awt.Image;

import javax.swing.ImageIcon;
import javax.swing.JDesktopPane;

public class DesktopPane extends JDesktopPane 
{
	private static final long serialVersionUID = 1L;
	private ImageIcon ico = new ImageIcon("E:\\java练习\\9353.jpg");
	
	public DesktopPane()
	{
		this(0,0);
	}
	
	public DesktopPane(int width, int heght)
	{
		getimage(width,heght);
	}
	
	public void getimage(int width, int heght)
	{
		ico.setImage(ico.getImage().getScaledInstance(width,heght,Image.SCALE_DEFAULT));
	}
	
	public void paintComponent(Graphics g)
	{
	     g.drawImage(ico.getImage(),0,0,this);
	}
}

重头戏代码：

[java] view plain copy

print ?

1. import java.awt.Container;  
2. import java.awt.Dimension;  
3. import java.awt.Font;  
4. import java.awt.Toolkit;  
5. import java.awt.event.ActionEvent;  
6. import java.awt.event.ActionListener;  
7. import java.lang.reflect.Constructor;  
8. import java.lang.reflect.InvocationTargetException;  
9. import java.lang.reflect.Method;  
10. import java.sql.Connection;  
11. import java.sql.ResultSet;  
12. import java.sql.SQLException;  
13. import java.util.ArrayList;  
14. import javax.swing.JButton;  
15. import javax.swing.JFrame;  
16. import javax.swing.JInternalFrame;  
17. import javax.swing.JMenu;  
18. import javax.swing.JMenuBar;  
19. import javax.swing.JMenuItem;  
20. import javax.swing.JToolBar;  
21. import javax.swing.event.InternalFrameEvent;  
22. import javax.swing.event.InternalFrameListener;  
23.   
24. public class myWindowsDate2   
25. {  
26.     /** 创建窗口的基本组件  */  
27.     private JFrame jfrmMain;  
28.     private Container con;  
29.       
30.     private JMenuBar jmenbTopBar = new JMenuBar();  
31.     private JInternalFrame jInternalFrame;  
32.     private DesktopPane  DesktopPane ;  
33.     private JToolBar toolBar ;  
34.       
35.     /** 分别用来存储SQL语句，取出的结果集，菜单类名字 */  
36.     String SQlString;  
37.     ResultSet  ResString ;  
38.     ResultSet result;  
39.     String className;  
40.       
41.     /** 连接数据库 */  
42.     Connection connection ;  
43.       
44.     /** 存储从数据库中取出的菜单的类型（类型有0、1、2）  */  
45.     int type;  
46.       
47.     /** 接收登入界面传入的用户姓名和ID*/  
48.     private String userId;  
49.     private String userName;  
50.       
51.     /** 存放已点击的菜单所调用的相对应的类名 */  
52.     private ArrayList<String> arrayListWindowCanSee  = new ArrayList<String>();  
53.     /** 存放可见和可用的的菜单项 */  
54.     private ArrayList<String> arrayListDo = new ArrayList<String>();  
55.     private ArrayList<String> arrayListIsCanUse = new ArrayList<String>();   
56.       
57.     /**  
58.      * 建立基本的窗体 
59.      * @author            王长春 
60.      * @param            void 
61.      * @return           void 
62.      * @exception        void 
63.      * */  
64.     public void creatJFram()  
65.     {  
66.         jfrmMain = new JFrame("微易码科技管理信息系统");   
67.         con = jfrmMain.getContentPane();  
68.         jfrmMain.setVisible(true);  
69.         jfrmMain.setExtendedState(jfrmMain.MAXIMIZED_BOTH);  
70.           
71.         Dimension don =Toolkit.getDefaultToolkit().getScreenSize();  
72.         jfrmMain.setSize(don.width,don.height);  
73.         jfrmMain.setLocation(0, 0);  
74.           
75.         DesktopPane = new DesktopPane(jfrmMain.getWidth(),jfrmMain.getHeight());  
76.       
77.         toolBar = new JToolBar();  
78.         con.add("North",toolBar);  
79.         con.add(DesktopPane);  
80.       
81.         jfrmMain.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);  
82.         jfrmMain.setVisible(true);  
83.                   
84.     }  
85.       
86.     /**  
87.      * 从数据库中取得菜单信息 
88.      * @author          王长春 
89.      * @param           void 
90.      * @return          void 
91.      * @exception       连接数据库和执行SQL语句，断开数据库时会出现异常 
92.      * */  
93.     public void DateFromDateBase()  
94.     {  
95.          SQlString = "SELECT Menu_Id, Menu_Name, Class_Name, Father_Id, Menu_Type " +  
96.                             "FROM SYS_INF_MAINMENU ";  
97.            
98.         MECDatabase date = new MECDatabase(1);  
99.         try   
100.         {  
101.             //连接数据库  
102.             date.connection("SYS_MEC_INFOTABLE");  
103.             result = date.select(SQlString);  
104.             //调用获得权限的方法  
105.             getPowerState();  
106.             //调用区分区分菜单项的方法  
107.             soutJMenu();  
108.             //断开数据库  
109.             date.disConnection();;  
110.         } catch (Exception e) {  
111.             e.printStackTrace();  
112.         }  
113.     }  
114.     /**  
115.      * 从数据库中取得用户对应的菜单应有的菜单权限 
116.      * @author          王长春 
117.      * @param           void 
118.      * @return          void 
119.      * @exception        连接数据库和执行SQL语句，断开数据库时会出现异常 
120.      * */  
121.     public void getPowerState()  
122.     {  
123.           
124.         String   sqlString;  
125.         String menuIdString;  
126.         int state;  
127.         //这里为简化操作（应该从登入界面传入的id号区别用户身份，直接从权限表中取得编号为02用户的权限  
128.         sqlString = "SELECT MenuId, MenuState FROM SYS_INF_POWER WHERE PostId = '02'";  
129.         MECDatabase  date1 = new MECDatabase(1);  
130.           
131.         try   
132.         {  
133.             date1.connection("SYS_MEC_INFOTABLE");  
134.             ResString = date1.select(sqlString);  
135.               
136.         } catch (Exception e)  
137.         {  
138.             e.printStackTrace();  
139.         }  
140.           
141.         try   
142.         {  //将用户可见和可用的挑出，并存放起来  
143.             while (ResString.next())   
144.             {  
145.                 menuIdString = ResString.getString("MenuId");  
146.                 state = ResString.getInt("MenuState");  
147.                   
148.                 if(state != 0)  
149.                     arrayListDo.add(menuIdString);  
150.                 if (state == 2 )  
151.                     arrayListIsCanUse.add(menuIdString);  
152.             }  
153.             date1.disConnection();  
154.         } catch (SQLException e)   
155.         {  
156.             e.printStackTrace();  
157.         } catch (Exception e) {  
158.             e.printStackTrace();  
159.         }  
160.     }  
161.       
162.     /** 区分菜单项所属的属性 
163.      * @author          王长春 
164.      * @param           void 
165.      * @return          void 
166.      * @exception       ClassNotFoundException,InstantiationException, 
167.      *                  IllegalAccessException,SQLException 
168.      *  
169.      * */  
170.     public void soutJMenu()  
171.     {  
172.         int  Finger_Move = 1;  
173.         try   
174.         {  
175.             while (result.next())  
176.             {     
177.                 String idString =result.getString("Menu_Id");  
178.                 String name = result.getString("Menu_Name");  
179.                  className = result.getString("Class_Name");  
180.                 String fatherIdString = result.getString("Father_Id");  
181.                 int type = result.getInt("Menu_Type");  
182.                   
183.                 if (0 == type && fatherIdString.equals("0000"))  
184.                 {//建立主菜单项  
185.                     JMenu tempJmenu = new JMenu(name);  
186.                     setJMenuItem(name, idString, fatherIdString, tempJmenu);  
187.                 }else if(2 == type)  
188.                 {//建立工具栏  
189.                     final JButton tempjButton = new JButton(name);  
190.                     tempjButton.setName(className);  
191.                     tempjButton.setFont(new Font("隶书",Font.BOLD,20));  
192.                     toolBar.add(tempjButton);  
193.                     tempjButton.addActionListener  
194.                     (  
195.                             new ActionListener()   
196.                             {  
197.                                 public void actionPerformed(ActionEvent arg0)   
198.                                 {  
199.                                     try {//调用反射机制的方法  
200.                                         creatNewWindow(tempjButton.getName(), userId, userName);  
201.                                     } catch (ClassNotFoundException e) {  
202.                                         e.printStackTrace();  
203.                                     } catch (InstantiationException e) {  
204.                                         e.printStackTrace();  
205.                                     } catch (IllegalAccessException e) {  
206.                                         e.printStackTrace();  
207.                                     }   
208.                                 }  
209.                             }  
210.                     );  
211.                 }  
212.                 Finger_Move++;  
213.                 result.absolute(Finger_Move);  
214.             }  
215.         }catch (SQLException e) {  
216.             e.printStackTrace();  
217.         }  
218.     }  
219.           
220.     /** 
221.      * 建立菜单项并且实现多级菜单的建立 
222.      * @author          王长春 
223.      * @return          Cycle_Index  int类型，记录的是result.next的执行次数，为返回result的指向做准备 
224.      * @param           nameString(String)  idstString(String)  fathetidString(String)  jmenu(String)   
225.      *                   传入soutJMenu()中的菜单名称，菜单编号，父菜单编号，和建立的JMenu 
226.      * @exception       ClassNotFoundException， InstantiationException，IllegalAccessException 
227.      * */  
228.     public int  setJMenuItem(String nameString, String idstString, String fathetidString, JMenu jmenu) throws SQLException  
229.     {  
230.         int Cycle_Index = 0;  
231.         boolean isSetSeparator = false;  
232.         boolean ifHeadhasItem = false;  
233.           
234.             if (fathetidString.equals("0000"))   
235.                 jmenbTopBar.add(jmenu);  
236.             while (result.next())   
237.              {  
238.                     Cycle_Index++;  
239.                       
240.                     String id = result.getString("Menu_Id");  
241.                     String Name = result.getString("Menu_Name");  
242.                     className = result.getString("Class_Name");  
243.                     String fatherIdString = result.getString("Father_Id");  
244.                     int type = result.getInt("Menu_Type");  
245.                       
246.                     if (fatherIdString.equals(idstString))  
247.                     {  
248.                         if (0 == type)  
249.                         {  
250.                             if(ifHeadhasItem && isSetSeparator)  
251.                             {  
252.                                     jmenu.addSeparator();  
253.                                     isSetSeparator = false;  
254.                             }  
255.                               
256.                             if (arrayListDo.contains(id))   
257.                             {  
258.                                   
259.                                 JMenu  tempjmenu = new JMenu(Name);  
260.                                 //递归调用  
261.                                 int count = setJMenuItem(Name, id,  fatherIdString, tempjmenu);  
262.                                 jmenu.add(tempjmenu);  
263.                                 //将 result的游标往回指  
264.                                 result.absolute(-count);  
265.                             }  
266.                         }  
267.                         else   
268.                         {  
269.                             if(Name.equals("-"))  
270.                                 isSetSeparator = true;  
271.                             else  
272.                             {   //添加分隔线，因为根据不同用户的权限不同，出现多根分隔线时只能添加一条，这里保证了  
273.                                 //既不多添加，也不少添加  
274.                                 if(ifHeadhasItem && isSetSeparator)  
275.                                 {  
276.                                         jmenu.addSeparator();  
277.                                         isSetSeparator = false;  
278.                                         ifHeadhasItem = false;  
279.                                 }  
280.                                   
281.                                 if (arrayListDo.contains(id))  
282.                                 {  
283.                                     //建立菜单项  
284.                                     final JMenuItem tempJMenuItem = new JMenuItem(Name);  
285.                                     tempJMenuItem.setName(className);  
286.                                     jmenu.add(tempJMenuItem);  
287.                                     ifHeadhasItem = true;  
288.                                     //判断是否可用  
289.                                     if (arrayListIsCanUse.contains(id))   
290.                                         tempJMenuItem.setEnabled(false);  
291.                                     tempJMenuItem.addActionListener  
292.                                     (  
293.                                       new ActionListener()  
294.                                      {  
295.                                      <span style="white-space:pre">   </span>public void actionPerformed(ActionEvent arg0)   
296.                                         {  
297.                                         <span style="white-space:pre">    </span>String ItemName = tempJMenuItem.getName();  
298.                                             try {  
299.                                                       
300.                                                  if (!(arrayListWindowCanSee.contains(ItemName)))   
301.                                                 {//计算器和万年历窗口要依附在我的主窗口中，两个是特殊处理  
302.                                                  if (!ItemName.equals("MECCalender") && !ItemName.equals("Calculator"))                                                 {                                                               <span style="white-space:pre">                </span> <span style="white-space:pre">      </span>creatNewWindow(ItemName, userId, userName);  
303.                                                         arrayListWindowCanSee.add(ItemName);  
304.                                                         DealAction(tempJMenuItem);  
305.                                                     }  
306.                                                     else   
307.                                                     creatSpecliWindow(ItemName, userId, userName);  
308.                                                 }  
309.                                                           
310.                                                  } catch (ClassNotFoundException e) {  
311.                                                     e.printStackTrace();  
312.                                                  } catch (InstantiationException e) {  
313.                                                     e.printStackTrace();  
314.                                                  } catch (IllegalAccessException e) {  
315.                                                     e.printStackTrace();  
316.                                                 }  
317.                                             }  
318.                                         }  
319.                                     );  
320.                                 }  
321.                                       
322.                             }  
323.                           
324.                         }     
325.                     }  
326.              }   
327.     return Cycle_Index + 1;  
328. }  
329.       
330.     /** 
331.      * 调用用户所点击的菜单项对应的类，弹出各个模块 
332.      * @author          王长春 
333.      * @param           string(String)类名字，id(String)用户编号， iString(String)用户名字 
334.      * @return          void 
335.      * @exception       ClassNotFoundException，InstantiationException，IllegalAccessException 
336.      *  <span style="white-space:pre">    </span>    NoSuchMethodException，SecurityException，InvocationTargetException 
337.      * */  
338.     public void creatNewWindow(String string, String  id ,String name) throws ClassNotFoundException, Instantia<span style="white-space:pre">                                 </span>tionException, IllegalAccessException  
339.     {  
340.             try {  
341.                 Class class1 = Class.forName(string);  
342.                 //要调用的方法的参数类型  
343.                 Class[]  paramType = {String.class, String.class};  
344.                 //实际传入的参数  
345.                 Object[]  param  = {id , name};   
346.                 //得到参数类型相同的构造方法  
347.                 Constructor constructor =class1.getConstructor(paramType);  
348.                 //传入参数，并执行构造方法  
349.                 Object  object = constructor.newInstance(param);  
350.                   
351.                 //调用getJframe的方法（各个模块统一留出一致的方法，），传入的参数为空  
352.                 Method method = class1.getMethod("getJframe", new Class[] {});  
353.                 //执行该方法  
354.                 Object mObject  =method.invoke(object, new Object[] {});  
355.                 jInternalFrame = (JInternalFrame) mObject;  
356.                 //将反回的窗体加入到我的窗体里面，成为我的子窗口  
357.                 DesktopPane.add(jInternalFrame);  
358.             } catch (NoSuchMethodException e) {  
359.                 e.printStackTrace();  
360.             } catch (SecurityException e) {  
361.                 e.printStackTrace();  
362.             } catch (IllegalArgumentException e) {  
363.                 e.printStackTrace();  
364.             } catch (InvocationTargetException e) {  
365.                 e.printStackTrace();  
366.             }  
367.     }  
368.       
369.       
370.     /** 
371.      * 调用用户所点击的菜单项中工具对应的类，弹出各个模块 
372.      * @author        王长春 
373.      * @param         string(String) 类名字，id(String)用户编号， iString(String)用户姓名 
374.      * @return        void 
375.      * @exception     ClassNotFoundException，InstantiationException，IllegalAccessException 
376.      *  <span style="white-space:pre">    </span>NoSuchMethodException，SecurityException，InvocationTargetException，NoSuchMethodException 
377.      * */  
378.     public void creatSpecliWindow(String ClassName,String userIdString, String userNameString )  
379.     {  
380.         try {  
381.             Class  clas2 = Class.forName(ClassName);  
382.             //要调用的方法的参数类型  
383.             Class[]  patrem = {JFrame.class, String.class, String.class};  
384.             //实际要传入的参数  
385.             Object[]  valueObjects =  {jfrmMain,  userIdString, userNameString};  
386.             //得到参数类型相同的构造方法  
387.             Constructor  constructor1 = clas2.getConstructor(patrem);  
388.             //传入参数，并执行构造方法  
389.             Object pObject = constructor1.newInstance(valueObjects);  
390.               
391.         } catch (ClassNotFoundException e)  
392.         {  
393.             e.printStackTrace();  
394.         } catch (NoSuchMethodException e) {  
395.             e.printStackTrace();  
396.         } catch (SecurityException e) {  
397.             e.printStackTrace();  
398.         } catch (InstantiationException e) {  
399.             e.printStackTrace();  
400.         } catch (IllegalAccessException e) {  
401.             e.printStackTrace();  
402.         } catch (IllegalArgumentException e) {  
403.             e.printStackTrace();  
404.         } catch (InvocationTargetException e) {  
405.             e.printStackTrace();  
406.         }  
407.     }  
408.       
409.     /** 
410.      * 对添加的JInterNalFream窗口进行事件监听 
411.      * @author       王长春 
412.      * @param        tempString(String) 事件监听时的菜单对象 
413.      * @return       void 
414.      * @exception    void 
415.      *  
416.      * */  
417.     public void DealAction(final JMenuItem tempItem)  
418.     {  
419.           
420.         jInternalFrame.addInternalFrameListener  
421.         (//对子窗体进行事件监听，子窗体没有关闭，再点击该菜单项不能在弹出该窗体  
422.                 new InternalFrameListener() {  
423.                     public void internalFrameOpened(InternalFrameEvent e) {  
424.                     }  
425.                     public void internalFrameIconified(InternalFrameEvent e) {}  
426.                     public void internalFrameDeiconified(InternalFrameEvent e) {}  
427.                     public void internalFrameDeactivated(InternalFrameEvent e) {  
428.                     }  
429.                     public void internalFrameClosing(InternalFrameEvent e) {}  
430.                     public void internalFrameClosed(InternalFrameEvent e){  
431.                         arrayListWindowCanSee.remove(tempItem.getName());  
432.                     }  
433.                     public void internalFrameActivated(InternalFrameEvent e){}  
434.                 }  
435.         );  
436.       
437.     }  
438.       
439.     /**初始化界面 
440.      * 构造方法 
441.      * @author       王长春 
442.      * @param        void 
443.      * @return       void 
444.      * @exception    void 
445.      *   */  
446.     public  myWindowsDate2()  
447.     {  
448.         creatJFram();  
449.         jfrmMain.setJMenuBar(jmenbTopBar);  
450.         DateFromDateBase();  
451.         jfrmMain.setVisible(true);  
452.     }  
453.       
454.       
455.     /** 
456.      * 带两个参数的构造方法，登入界面传入参数 
457.      * @author      王长春 
458.      * @param      String  userId 登入界面传入的用户编号, String  userName 登入界面传入的用户姓名 
459.      * @return      void 
460.      * @exception   void 
461.      * */  
462.     public myWindowsDate2(String userId, String userName)  
463.     {  
464.         this.userId = userId;  
465.         this.userName = userName;  
466.         creatJFram();  
467.         jfrmMain.setJMenuBar(jmenbTopBar);  
468.         DateFromDateBase();  
469.         jfrmMain.setVisible(true);  
470.           
471.     }  
472.       
473.     /** 
474.      * 主函数 
475.      * @author          王长春 
476.      * @param           void 
477.      * @return          void 
478.      * @exception       void  
479.      * */  
480.     public static void main(String[] args)   
481.     {  
482.         new myWindowsDate2();  
483.     }  
484.   
485. }  

import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JInternalFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JToolBar;
import javax.swing.event.InternalFrameEvent;
import javax.swing.event.InternalFrameListener;

public class myWindowsDate2 
{
	/** 创建窗口的基本组件  */
	private JFrame jfrmMain;
	private Container con;
	
	private JMenuBar jmenbTopBar = new JMenuBar();
	private JInternalFrame jInternalFrame;
	private DesktopPane  DesktopPane ;
	private JToolBar toolBar ;
	
	/** 分别用来存储SQL语句，取出的结果集，菜单类名字 */
	String SQlString;
	ResultSet  ResString ;
	ResultSet result;
	String className;
	
	/** 连接数据库 */
	Connection connection ;
	
	/** 存储从数据库中取出的菜单的类型（类型有0、1、2）  */
	int type;
	
	/** 接收登入界面传入的用户姓名和ID*/
	private String userId;
	private String userName;
	
	/** 存放已点击的菜单所调用的相对应的类名 */
	private ArrayList<String> arrayListWindowCanSee  = new ArrayList<String>();
	/** 存放可见和可用的的菜单项 */
	private ArrayList<String> arrayListDo = new ArrayList<String>();
	private ArrayList<String> arrayListIsCanUse = new ArrayList<String>(); 
	
	/** 
	 * 建立基本的窗体
	 * @author		  	  王长春
	 * @param        	 void
	 * @return 		 	 void
	 * @exception   	 void
	 * */
	public void creatJFram()
	{
		jfrmMain = new JFrame("微易码科技管理信息系统"); 
		con = jfrmMain.getContentPane();
		jfrmMain.setVisible(true);
		jfrmMain.setExtendedState(jfrmMain.MAXIMIZED_BOTH);
		
		Dimension don =Toolkit.getDefaultToolkit().getScreenSize();
		jfrmMain.setSize(don.width,don.height);
		jfrmMain.setLocation(0, 0);
		
		DesktopPane = new DesktopPane(jfrmMain.getWidth(),jfrmMain.getHeight());
	
		toolBar = new JToolBar();
		con.add("North",toolBar);
		con.add(DesktopPane);
	
		jfrmMain.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
		jfrmMain.setVisible(true);
				
	}
	
	/** 
	 * 从数据库中取得菜单信息
	 * @author 			王长春
	 * @param			void
	 * @return			void
	 * @exception   	连接数据库和执行SQL语句，断开数据库时会出现异常
	 * */
	public void DateFromDateBase()
	{
		 SQlString = "SELECT Menu_Id, Menu_Name, Class_Name, Father_Id, Menu_Type " +
							"FROM SYS_INF_MAINMENU ";
		 
		MECDatabase date = new MECDatabase(1);
		try 
		{
			//连接数据库
			date.connection("SYS_MEC_INFOTABLE");
			result = date.select(SQlString);
			//调用获得权限的方法
			getPowerState();
			//调用区分区分菜单项的方法
			soutJMenu();
			//断开数据库
			date.disConnection();;
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/** 
	 * 从数据库中取得用户对应的菜单应有的菜单权限
	 * @author 			王长春
	 * @param			void
	 * @return			void
	 * @exception  		 连接数据库和执行SQL语句，断开数据库时会出现异常
	 * */
	public void getPowerState()
	{
		
		String   sqlString;
		String menuIdString;
		int state;
		//这里为简化操作（应该从登入界面传入的id号区别用户身份，直接从权限表中取得编号为02用户的权限
		sqlString = "SELECT MenuId, MenuState FROM SYS_INF_POWER WHERE PostId = '02'";
		MECDatabase  date1 = new MECDatabase(1);
		
		try 
		{
			date1.connection("SYS_MEC_INFOTABLE");
			ResString = date1.select(sqlString);
			
		} catch (Exception e)
		{
			e.printStackTrace();
		}
		
		try 
		{  //将用户可见和可用的挑出，并存放起来
			while (ResString.next()) 
			{
				menuIdString = ResString.getString("MenuId");
				state = ResString.getInt("MenuState");
				
				if(state != 0)
					arrayListDo.add(menuIdString);
				if (state == 2 )
					arrayListIsCanUse.add(menuIdString);
			}
			date1.disConnection();
		} catch (SQLException e) 
		{
			e.printStackTrace();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	/** 区分菜单项所属的属性
	 * @author 			王长春
	 * @param			void
	 * @return			void
	 * @exception  		ClassNotFoundException,InstantiationException,
	 * 			   		IllegalAccessException,SQLException
	 * 
	 * */
	public void soutJMenu()
	{
		int  Finger_Move = 1;
		try 
		{
			while (result.next())
			{	
				String idString =result.getString("Menu_Id");
				String name = result.getString("Menu_Name");
				 className = result.getString("Class_Name");
				String fatherIdString = result.getString("Father_Id");
				int type = result.getInt("Menu_Type");
				
				if (0 == type && fatherIdString.equals("0000"))
				{//建立主菜单项
					JMenu tempJmenu = new JMenu(name);
					setJMenuItem(name, idString, fatherIdString, tempJmenu);
				}else if(2 == type)
				{//建立工具栏
					final JButton tempjButton = new JButton(name);
					tempjButton.setName(className);
					tempjButton.setFont(new Font("隶书",Font.BOLD,20));
					toolBar.add(tempjButton);
					tempjButton.addActionListener
					(
							new ActionListener() 
							{
								public void actionPerformed(ActionEvent arg0) 
								{
									try {//调用反射机制的方法
										creatNewWindow(tempjButton.getName(), userId, userName);
									} catch (ClassNotFoundException e) {
										e.printStackTrace();
									} catch (InstantiationException e) {
										e.printStackTrace();
									} catch (IllegalAccessException e) {
										e.printStackTrace();
									} 
								}
							}
					);
				}
				Finger_Move++;
				result.absolute(Finger_Move);
			}
		}catch (SQLException e) {
			e.printStackTrace();
		}
	}
		
	/**
	 * 建立菜单项并且实现多级菜单的建立
	 * @author 			王长春
	 * @return  		Cycle_Index  int类型，记录的是result.next的执行次数，为返回result的指向做准备
	 * @param 			nameString(String)  idstString(String)  fathetidString(String)  jmenu(String)  
	 * 		   			 传入soutJMenu()中的菜单名称，菜单编号，父菜单编号，和建立的JMenu
	 * @exception  		ClassNotFoundException， InstantiationException，IllegalAccessException
	 * */
	public int  setJMenuItem(String nameString, String idstString, String fathetidString, JMenu jmenu) throws SQLException
	{
		int Cycle_Index = 0;
		boolean isSetSeparator = false;
		boolean ifHeadhasItem = false;
		
			if (fathetidString.equals("0000")) 
				jmenbTopBar.add(jmenu);
			while (result.next()) 
			 {
					Cycle_Index++;
					
					String id = result.getString("Menu_Id");
					String Name = result.getString("Menu_Name");
					className = result.getString("Class_Name");
					String fatherIdString = result.getString("Father_Id");
					int type = result.getInt("Menu_Type");
					
					if (fatherIdString.equals(idstString))
					{
						if (0 == type)
						{
							if(ifHeadhasItem && isSetSeparator)
							{
									jmenu.addSeparator();
									isSetSeparator = false;
							}
							
							if (arrayListDo.contains(id)) 
							{
								
								JMenu  tempjmenu = new JMenu(Name);
								//递归调用
								int count = setJMenuItem(Name, id,  fatherIdString, tempjmenu);
								jmenu.add(tempjmenu);
								//将 result的游标往回指
								result.absolute(-count);
							}
						}
						else 
						{
							if(Name.equals("-"))
								isSetSeparator = true;
							else
							{	//添加分隔线，因为根据不同用户的权限不同，出现多根分隔线时只能添加一条，这里保证了
								//既不多添加，也不少添加
								if(ifHeadhasItem && isSetSeparator)
								{
										jmenu.addSeparator();
										isSetSeparator = false;
										ifHeadhasItem = false;
								}
								
								if (arrayListDo.contains(id))
								{
									//建立菜单项
									final JMenuItem tempJMenuItem = new JMenuItem(Name);
									tempJMenuItem.setName(className);
									jmenu.add(tempJMenuItem);
									ifHeadhasItem = true;
									//判断是否可用
									if (arrayListIsCanUse.contains(id)) 
										tempJMenuItem.setEnabled(false);
									tempJMenuItem.addActionListener
									(
									  new ActionListener()
									 {
									 <span style="white-space:pre">	</span>public void actionPerformed(ActionEvent arg0) 
										{
										<span style="white-space:pre">	</span>String ItemName = tempJMenuItem.getName();
											try {
													
												 if (!(arrayListWindowCanSee.contains(ItemName))) 
												{//计算器和万年历窗口要依附在我的主窗口中，两个是特殊处理
												 if (!ItemName.equals("MECCalender") && !ItemName.equals("Calculator"))												    {																<span style="white-space:pre">				</span> <span style="white-space:pre">		</span>creatNewWindow(ItemName, userId, userName);
														arrayListWindowCanSee.add(ItemName);
														DealAction(tempJMenuItem);
												    }
												    else 
													creatSpecliWindow(ItemName, userId, userName);
												}
														
											     } catch (ClassNotFoundException e) {
													e.printStackTrace();
											     } catch (InstantiationException e) {
													e.printStackTrace();
											     } catch (IllegalAccessException e) {
													e.printStackTrace();
												}
											}
										}
									);
								}
									
							}
						
						}	
					}
			 } 
	return Cycle_Index + 1;
}
	
	/**
	 * 调用用户所点击的菜单项对应的类，弹出各个模块
	 * @author          王长春
	 * @param           string(String)类名字，id(String)用户编号， iString(String)用户名字
	 * @return          void
	 * @exception       ClassNotFoundException，InstantiationException，IllegalAccessException
	 * 	<span style="white-space:pre">	</span>    NoSuchMethodException，SecurityException，InvocationTargetException
	 * */
	public void creatNewWindow(String string, String  id ,String name) throws ClassNotFoundException, Instantia<span style="white-space:pre">									</span>tionException, IllegalAccessException
	{
			try {
				Class class1 = Class.forName(string);
				//要调用的方法的参数类型
				Class[]  paramType = {String.class, String.class};
				//实际传入的参数
				Object[]  param  = {id , name}; 
				//得到参数类型相同的构造方法
				Constructor constructor =class1.getConstructor(paramType);
				//传入参数，并执行构造方法
				Object  object = constructor.newInstance(param);
				
				//调用getJframe的方法（各个模块统一留出一致的方法，），传入的参数为空
				Method method = class1.getMethod("getJframe", new Class[] {});
				//执行该方法
				Object mObject  =method.invoke(object, new Object[] {});
				jInternalFrame = (JInternalFrame) mObject;
				//将反回的窗体加入到我的窗体里面，成为我的子窗口
				DesktopPane.add(jInternalFrame);
			} catch (NoSuchMethodException e) {
				e.printStackTrace();
			} catch (SecurityException e) {
				e.printStackTrace();
			} catch (IllegalArgumentException e) {
				e.printStackTrace();
			} catch (InvocationTargetException e) {
				e.printStackTrace();
			}
	}
	
	
	/**
	 * 调用用户所点击的菜单项中工具对应的类，弹出各个模块
	 * @author        王长春
	 * @param         string(String) 类名字，id(String)用户编号， iString(String)用户姓名
	 * @return        void
	 * @exception     ClassNotFoundException，InstantiationException，IllegalAccessException
	 * 	<span style="white-space:pre">	</span>NoSuchMethodException，SecurityException，InvocationTargetException，NoSuchMethodException
	 * */
	public void creatSpecliWindow(String ClassName,String userIdString, String userNameString )
	{
		try {
			Class  clas2 = Class.forName(ClassName);
			//要调用的方法的参数类型
			Class[]  patrem = {JFrame.class, String.class, String.class};
			//实际要传入的参数
			Object[]  valueObjects =  {jfrmMain,  userIdString, userNameString};
			//得到参数类型相同的构造方法
			Constructor  constructor1 = clas2.getConstructor(patrem);
			//传入参数，并执行构造方法
			Object pObject = constructor1.newInstance(valueObjects);
			
		} catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		} catch (NoSuchMethodException e) {
			e.printStackTrace();
		} catch (SecurityException e) {
			e.printStackTrace();
		} catch (InstantiationException e) {
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			e.printStackTrace();
		} catch (IllegalArgumentException e) {
			e.printStackTrace();
		} catch (InvocationTargetException e) {
			e.printStackTrace();
		}
	}
	
	/**
	 * 对添加的JInterNalFream窗口进行事件监听
	 * @author       王长春
	 * @param        tempString(String) 事件监听时的菜单对象
	 * @return       void
	 * @exception    void
	 * 
	 * */
	public void DealAction(final JMenuItem tempItem)
	{
		
		jInternalFrame.addInternalFrameListener
		(//对子窗体进行事件监听，子窗体没有关闭，再点击该菜单项不能在弹出该窗体
				new InternalFrameListener() {
					public void internalFrameOpened(InternalFrameEvent e) {
					}
					public void internalFrameIconified(InternalFrameEvent e) {}
					public void internalFrameDeiconified(InternalFrameEvent e) {}
					public void internalFrameDeactivated(InternalFrameEvent e) {
					}
					public void internalFrameClosing(InternalFrameEvent e) {}
					public void internalFrameClosed(InternalFrameEvent e){
						arrayListWindowCanSee.remove(tempItem.getName());
					}
					public void internalFrameActivated(InternalFrameEvent e){}
				}
		);
	
	}
	
	/**初始化界面
	 * 构造方法
	 * @author 		 王长春
	 * @param 		 void
	 * @return 		 void
	 * @exception 	 void
	 * 	 */
	public  myWindowsDate2()
	{
		creatJFram();
		jfrmMain.setJMenuBar(jmenbTopBar);
		DateFromDateBase();
		jfrmMain.setVisible(true);
	}
	
	
	/**
	 * 带两个参数的构造方法，登入界面传入参数
	 * @author      王长春
	 * @param      String  userId 登入界面传入的用户编号, String  userName 登入界面传入的用户姓名
	 * @return   	void
	 * @exception   void
	 * */
	public myWindowsDate2(String userId, String userName)
	{
		this.userId = userId;
		this.userName = userName;
		creatJFram();
		jfrmMain.setJMenuBar(jmenbTopBar);
		DateFromDateBase();
		jfrmMain.setVisible(true);
		
	}
	
	/**
	 * 主函数
	 * @author  		王长春
	 * @param   		void
	 * @return  		void
	 * @exception 	    void 
	 * */
	public static void main(String[] args) 
	{
		new myWindowsDate2();
	}

}

看看最后运行的效果吧：

点击菜单项后出现相应的界面，弹出界面的代码就不再这里展示了:

顶

1

踩

0

 

 

• 上一篇Java的反射机制
• 下一篇Android Fragment生命周期

  相关文章推荐

• • java后台动态创建三级菜单
• • 【直播】70天软考冲刺计划--任铄
• • （四）shiro注解授权和jsp标签授权
• • 【直播】打通Linux脉络 进程、线程、调度--宋宝华
• • zTree实现基本树
• • 【直播】机器学习之凸优化--马博士
• • mysql 回滚，撤销操作，恢复数据
• • 【套餐】MATLAB基础+MATLAB数据分析与统计--魏伟

• • Java数据库获取动态主菜单和子菜单或上下级关联菜单+jquery页面展示
• • 【课程】3小时掌握Docker最佳实战--徐西宁
• • Java 创建动态类和查看方法列表信息
• • 【课程】深度学习基础与TensorFlow实践--AI100
• • asp.net下论坛中动态菜单的编程(C#)
• • java 通过代码实现动态选择数据源
• • ASP.NET+SQL SERVER 动态加载菜单详解
• • MFC中的CMenu---如何动态添加菜单/菜单项、子菜单、右键菜单