Go语言视频零基础入门到精通

javalearner

Swing是目前java中不可缺少的窗口工具组，是用户建立图形化用户界面（GUI）程序的强大工具。Java Swing组件自动产生各种事件来响应用户行为。如当用户点击按钮或选择菜单项目时，Swing组件会产生一个ActionEvent。Swing组件会产生许多事件，如ActionEvents,ChangeEvents,ItemEvents等，来响应用户的鼠标点击行为，列表框中值的改变，计时器的开始计时等行为。在Java Swing编程中，通过注册监听器，我们可以监听事件源产生的事件，从而在事件处理程序中处理我们所需要处理的用户行为。

Java Swing中处理各组件事件的一般步骤是：
1． 新建一个组件（如JButton）。

2． 将该组件添加到相应的面板（如JPanel）。

3． 注册监听器以监听事件源产生的事件（如通过ActionListener来响应用户点击按钮）。

4． 定义处理事件的方法（如在ActionListener中的actionPerformed中定义相应方法）。
  
   
   
     
   

     
   
  
     以上步骤我们可以用多种方法实现。但人们通常用二种方法。
第一种方法是只利用一个监听器以及多个if语句来决定是哪个组件产生的事件；

第二种方法是使用多个内部类来响应不同组件产生的各种事件，其具体实现又分两种方式，一种是匿名内部类，一种是一般内部类。

为了说明如何使用上述三种方法实现事件的处理方法，我们建立一个简单的应用程序。该程序界面有两个按钮，当用户点击相应的按钮，就会弹出一个对话框显示相应的内容。通过这个简单程序，你可以实现自己更多、更复杂的用户界面程序。 首先，我们利用单个监听器来实现该程序。我们定义一个名为Simple1的类来包括所有代码。所有的用户行为（如点击按钮）由一个监听器 SimpleListenner中的actionPerformed方法来处理。 以下是代码：

1. 
   
2.     /*
   
3.     * Simple1.java - 处理事件的第一种方法
   
4.     * 在这个例子中，利用一个ActionListener来监听事件源产生的事件
   
5.     * 用一些if语句来决定是哪个事件源
   
6.     */
   
7.     import java.awt.*;
   
8.     import java.awt.event.*;
   
9.     import javax.swing.*;
   
10.     public class Simple1
    
11.     {
    
12.     private static JFrame frame; // 定义为静态变量以便main使用
    
13.     private static JPanel myPanel; // 该面板用来放置按钮组件
    
14.     private JButton button1;    // 这里定义按钮组件
    
15.     private JButton button2;    // 以便让ActionListener使用
    
16.     public Simple1()             // 构造器, 建立图形界面
    
17.     {
    
18.            // 新建面板
    
19.            myPanel = new JPanel();
    
20.            // 新建按钮
    
21.            button1 = new JButton("按钮1");   // 新建按钮1
    
22.            button2 = new JButton("按钮2");
    
23.            SimpleListener ourListener = new SimpleListener();
    
24.     // 建立一个actionlistener让两个按钮共享
    
25.            button1.addActionListener(ourListener);
    
26.            button2.addActionListener(ourListener);
    
27.            myPanel.add(button1); // 添加按钮到面板
    
28.            myPanel.add(button2);
    
29.     }
    
30.     private class SimpleListener implements ActionListener
    
31.     {
    
32.     /*
    
33.         * 利用该内部类来监听所有事件源产生的事件
    
34.         * 便于处理事件代码模块化
    
35.         */
    
36.            public void actionPerformed(ActionEvent e)
    
37.            {
    
38.              // 利用getActionCommand获得按钮名称
    
39.              // 也可以利用getSource()来实现
    
40.              // if (e.getSource() ==button1)
    
41.              String buttonName = e.getActionCommand();
    
42.              if (buttonName.equals("按钮1")
    
43.                 JOptionPane.showMessageDialog(frame,
    
44.                                                "按钮1 被点击";
    
45.              else if (buttonName.equals("按钮2")
    
46.                 JOptionPane.showMessageDialog(frame,
    
47.                                                "按钮2 被点击");
    
48.              else
    
49.                 JOptionPane.showMessageDialog(frame,
    
50.                                                "Unknown event" );
    
51.            }
    
52.     }
    
53.     public static void main(String s[])
    
54.     {
    
55.            Simple1 gui = new Simple1(); // 新建Simple1组件
    
56.            frame = new JFrame("Simple1");   // 新建JFrame
    
57.            // 处理关闭事件的通常方法
    
58.            frame.addWindowListener(new WindowAdapter() {
    
59.              public void windowClosing(WindowEvent e)
    
60.                  {System.exit(0);} });
    
61.            frame.getContentPane().add(myPanel);
    
62.            frame.pack();               
    
63.            frame.setVisible(true);
    
64.            }
    
65.     }

复制代码

让我们来看看以上代码是如何工作的。在main方法中，我们定义了一个JFrame，然后将面板Jpanel添加到窗体中，该面板包括两个按钮。相应的变量Frame,button1,button2定义在程序的开头部分。 在程序入口main方法中，首先新建Simple1组件，通过构造器建立用户GUI，定义一个面板Jpanle,，增加两个按钮，然后利用 JButton.addActionListerner将两个按钮加入到一个活动监听器SimpleLister中，最后，两个按钮添加到面板。当GUI 建立后，我们将面板添加到窗体并显示结果。当用户点击按钮时，程序调用actionPerformed方法，通过if语句来判断是哪一个按钮被点击，然后在对话框中显示相应的内容。 利用一个监听器来处理事件的缺点是，当程序比较复杂时，需要一大串的if 语句来实现，程序代码较难阅读与维护。当然，如果处理的事件较少，这种方式比较简单。 通过使用匿名内部类可以解决上述存在的问题。使用简单的匿名内部类作为addActionListener的变量即可。 以下是实现代码：

1. 
   
2.     /*
   
3.     * Simple2.java - 处理事件的第二种方法
   
4.     * 在这个例子中，利用匿名内部类来监听每一个事件源产生的事件
   
5.     * 避免使用一些if语句来决定是哪个事件源
   
6.     */
   
7.     import java.awt.*;
   
8.     import java.awt.event.*;
   
9.     import javax.swing.*;
   
10.     public class Simple2
    
11.     {
    
12.     private static JFrame frame; // 定义为静态变量以便main使用
    
13.     private static JPanel myPanel; // 该面板用来放置按钮组件
    
14.     private JButton button1;    // 这里定义按钮组件
    
15.     private JButton button2;    // 以便让ActionListener使用
    
16.     public Simple2()             // 构造器, 建立图形界面
    
17.         {
    
18.            // 新建面板
    
19.            myPanel = new JPanel();
    
20.            // 新建按钮
    
21.            button1 = new JButton("按钮1");   // 新建按钮1
    
22.            button2 = new JButton("按钮2");
    
23.            // 每一个事件源需要一个监听器
    
24.            // 定义一个匿名内部类来监听事件源产生的事件
    
25.            button1.addActionListener(
    
26.              new ActionListener()
    
27.              {
    
28.                 public void actionPerformed(ActionEvent e)
    
29.                 {
    
30.                        JOptionPane.showMessageDialog(frame,
    
31.                                            "按钮1 被点击");
    
32.                 }
    
33.              }
    
34.            );
    
35.            button2.addActionListener(
    
36.              new ActionListener()
    
37.              {
    
38.                 public void actionPerformed(ActionEvent e)
    
39.                 {
    
40.                        JOptionPane.showMessageDialog(frame,
    
41.                                                "按钮2 被点击");
    
42.                 }
    
43.              }
    
44.            );
    
45.            myPanel.add(button1);        // 添加按钮到面板
    
46.            myPanel.add(button2);
    
47.     }
    
48.     public static void main(String s[])
    
49.     {
    
50.            Simple2 gui = new Simple2(); // 新建Simple2组件
    
51.            frame = new JFrame("Simple2");   // 新建JFrame
    
52.            // 处理关闭事件的通常方法
    
53.            frame.addWindowListener(new WindowAdapter() {
    
54.              public void windowClosing(WindowEvent e)
    
55.                  {System.exit(0);} });
    
56.            frame.getContentPane().add(myPanel);
    
57.            frame.pack();               
    
58.            frame.setVisible(true);
    
59.            }
    
60.     }

复制代码

使用匿名内部类同样存在许多另外的问题。首先，根据组件在代码中被定义的不同位置，类的定义以及处理事件的代码将分散在程序的各个部分，不是集中在一块，同样不便于阅读与维护。各事件的处理全部由嵌套的程序块组成，视觉上很难定位程序代码。如果事件处理程序比较复杂，内部类中的代码将变得很长，你将找不到相应的组件定义位置。最后，当工具栏、菜单栏目等需要处理同样的用户行为时，该方法将使代码更难维护。 我们使用一般的命名内部类可以解决以上许多问题。所有的事件处理方法都集中在一块，并且都具有有意义的名称，程序非常容易阅读与维护。单个的事件处理程序也可以被工具栏、菜单栏等重复使用， 以下是实现代码：

1. 
   
2.     /*
   
3.     * Simple3.java - 处理事件的第三种方法
   
4.     * For this example, we will use inner member classes to
   
5.     * 在这个例子中，利用一般内部类来监听每个事件源产生的事件
   
6.     * 该方法避免了第二种方法中由于使用匿名内部类而导致的代码混乱
   
7.     * 便于集中处理事件代码
   
8.     * 每一个Hander可以被工具栏或菜单多次使用
   
9.     */
   
10.     import java.awt.*;
    
11.     import java.awt.event.*;
    
12.     import javax.swing.*;
    
13.     public class Simple3
    
14.     {
    
15.     private static JFrame frame; // 定义为静态变量以便main使用
    
16.     private static JPanel myPanel; // 该面板用来放置按钮组件
    
17.     private JButton button1;    // 这里定义按钮组件
    
18.     private JButton button2;    // 以便让ActionListener使用
    
19.     // 利用一般内部类来监听每一个事件源产生的事件如(button1, button2)
    
20.     private class Button1Handler implements ActionListener
    
21.     {
    
22.            public void actionPerformed(ActionEvent e)
    
23.            {
    
24.              JOptionPane.showMessageDialog(frame,
    
25.                                             "按钮1 被点击");
    
26.            }
    
27.     }
    
28.     private class Button2Handler implements ActionListener
    
29.     {
    
30.            public void actionPerformed(ActionEvent e)
    
31.            {
    
32.              JOptionPane.showMessageDialog(frame,
    
33.                                             "按钮2 被点击");
    
34.            }
    
35.     }
    
36.     public Simple3()             //   // 构造器, 建立图形界面
    
37.     {
    
38.           // 新建面板
    
39.            myPanel = new JPanel();
    
40.            // 新建按钮
    
41.            button1 = new JButton("按钮1");   // 新建按钮1
    
42.            button2 = new JButton("按钮2");
    
43.            // 对每一个组件注册监听内部类
    
44.            button1.addActionListener(new Button1Handler());
    
45.            button2.addActionListener(new Button2Handler());
    
46.            myPanel.add(button1);        // 添加按钮到面板
    
47.            myPanel.add(button2);
    
48.     }
    
49.     public static void main(String s[])
    
50.     {
    
51.            Simple3 gui = new Simple3();   // 新建Simple3组件
    
52.            frame = new JFrame("Simple3");   // 新建JFrame
    
53.            // 处理关闭事件的通常方法        
    
54.            frame.addWindowListener(new WindowAdapter() {
    
55.              public void windowClosing(WindowEvent e)
    
56.                  {System.exit(0);} });
    
57.            frame.getContentPane().add(myPanel);
    
58.            frame.pack();               
    
59.            frame.setVisible(true);
    
60.            }
    
61.     }
    

复制代码

以上分析了在Java Swing中三种事件的处理方式，其中利用一般内部类来实现的方法，从代码书写、阅读、维护以及程序的可扩展性角度来看，最为值得推荐供大家使用。



  
  
   
   

     
   

     
   
  

复制代码