WindowAdapter适配器类

WindowAdapter适配器类

//转载 

 

Java WindowAdapter适配器类

 

  并不是所有的事件处理都像按钮点击那样简单。在正规的程序中，往往希望用户在确认没有丢失所做工作之后再关闭程序。当用户关闭框架时，可能希望弹出一个对话框来警告用户没有保存的工作有可能会丢失，只有在用户确认之后才退出程序。

  当程序用户试图关闭一个框架窗口时，JFrame对象就是WindowEvent的事件源。如果希望捕获这个事件，就必须有一个适合的监听器对象，并将它添加到框架的窗口监听器列表中。

  窗口监听器必须是实现WindowListener接口的类的一个对象。在WindowListener接口中包含7个方法。当发生窗口事件时，框架将调用这些方法响应7个不同的事件。从它们的名字就可以得知其作用，唯一的例外是在Windows下，通常将iconified称为minimized。

 

1. public interface WindowListener extends EventListener {  
2.     /** 
3.      * Invoked the first time a window is made visible. 
4.      */  
5.     public void windowOpened(WindowEvent e);  
6.   
7.     /** 
8.      * Invoked when the user attempts to close the window 
9.      * from the window's system menu. 
10.      */  
11.     public void windowClosing(WindowEvent e);  
12.   
13.     /** 
14.      * Invoked when a window has been closed as the result 
15.      * of calling dispose on the window. 
16.      */  
17.     public void windowClosed(WindowEvent e);  
18.   
19.     /** 
20.      * Invoked when a window is changed from a normal to a 
21.      * minimized state. For many platforms, a minimized window  
22.      * is displayed as the icon specified in the window's  
23.      * iconImage property. 
24.      * @see java.awt.Frame#setIconImage 
25.      */  
26.     public void windowIconified(WindowEvent e);  
27.   
28.     /** 
29.      * Invoked when a window is changed from a minimized 
30.      * to a normal state. 
31.      */  
32.     public void windowDeiconified(WindowEvent e);  
33.   
34.     /** 
35.      * Invoked when the Window is set to be the active Window. Only a Frame or 
36.      * a Dialog can be the active Window. The native windowing system may 
37.      * denote the active Window or its children with special decorations, such 
38.      * as a highlighted title bar. The active Window is always either the 
39.      * focused Window, or the first Frame or Dialog that is an owner of the 
40.      * focused Window. 
41.      */  
42.     public void windowActivated(WindowEvent e);  
43.   
44.     /** 
45.      * Invoked when a Window is no longer the active Window. Only a Frame or a 
46.      * Dialog can be the active Window. The native windowing system may denote 
47.      * the active Window or its children with special decorations, such as a 
48.      * highlighted title bar. The active Window is always either the focused 
49.      * Window, or the first Frame or Dialog that is an owner of the focused 
50.      * Window. 
51.      */  
52.     public void windowDeactivated(WindowEvent e);  
53. }  

  在Java中，实现一个接口的任何类都必须实现其中的所有方法；在这里，意味着需要实现7个方法。然而这里如果我们只对名为windowClosing的方法感兴趣。

 

  当然，可以这样定义实现这个接口的类：在windowClosing方法中增加一个对System.out.println("TerminatorListener--windowClosing");的调用，其它6个方法不做任何事情：

 

1. class TerminatorListener implements WindowListener {  
2.   
3.     public void windowClosing(WindowEvent e) {  
4.         System.out.println("TerminatorListener--windowClosing");  
5.     }  
6.   
7.     @Override  
8.     public void windowOpened(WindowEvent e) {  
9.         // throw new UnsupportedOperationException("Not supported yet.");  
10.     }  
11.   
12.     @Override  
13.     public void windowClosed(WindowEvent e) {  
14.         //throw new UnsupportedOperationException("Not supported yet.");  
15.     }  
16.   
17.     @Override  
18.     public void windowIconified(WindowEvent e) {  
19.         //throw new UnsupportedOperationException("Not supported yet.");  
20.     }  
21.   
22.     @Override  
23.     public void windowDeiconified(WindowEvent e) {  
24.         //throw new UnsupportedOperationException("Not supported yet.");  
25.     }  
26.   
27.     @Override  
28.     public void windowActivated(WindowEvent e) {  
29.         //  throw new UnsupportedOperationException("Not supported yet.");  
30.     }  
31.   
32.     @Override  
33.     public void windowDeactivated(WindowEvent e) {  
34.         //  throw new UnsupportedOperationException("Not supported yet.");  
35.     }  
36. }  

  书写6个没有任何操作的方法代码显然是一种乏味的工作。鉴于简化的目的，每个含有多个方法的AWT监听器接口都配有一个适配器（adapter）类，这个类实现了接口中的所有方法，但每个方法没有做任何事情。这意味着适配器类自动地满足了Java实现相关监听器接口的技术需求。可以通过扩展适配器类来指定对某些事件的响应动作，而不必实现接口中的每个方法（ActionListener这样的接口只有一个方法，因此没必要提供适配器类）。

 

  下面使用窗口适配器。首先定义一个WindowAdapter类的扩展类，其中包含继承的6个没有做任何事情的方法和一个覆盖的方法windowClosing：

 

1. class TerminatorAdapter extends WindowAdapter {  
2.   
3.     public void windowClosing(WindowEvent e) {  
4.         System.out.println("TerminatorAdapter---windowClosing");  
5.     }  
6. }  

  现在，可以将一个Terminator对象注册为事件监听器：

 

 

1. WindowListener listenerAdapter = new TerminatorAdapter();  
2. adapterFrame.addWindowListener(listenerAdapter);  

  只要框架产生了窗口事件，就会通过调用7个方法之中的一个方法将事件传递给listener对象，其中6个方法没有做过任何事情；windowClosing方法调用System.exit(0)终止应用程序的执行。

 

  警告：如果在扩展适配器类时将方法名拼写错了，编译器不会捕获到这个错误。例如，如果在WindowAdapter类中定义一个windowIsClosing方法，就会得到一个包含8个方法的类，并且windowClosing方法没有做任何事情。

  创建一个扩展于WindowAdapter的监听器类是一个很好的改进，但是还可以继续改进。事实上，没有必要为listener对象命名。只需写成：

 

1. adapterFrame.addWindowListener(new WindowAdapter());  

  不要就此止步！我们可以将监听器类定义为框架的匿名内部类。

 

 

1. adapterFrame.addWindowListener(new WindowAdapter() {  
2.   
3.      public void windowClosing(WindowEvent e) {  
4.          System.out.println("Terminator--windowClosing");  
5.      }  
6. });  

  这段代码具有下列作用：

 

  定义了一个扩展于WindowAdapter类的无名类。

  将windowClosing方法添加到匿名类中。

  从WindowAdapter继承6个没有做任何事情的方法。

  创建这个类的一个对象，这个对象没有名字。

  将这个对象传递给addWindowListener方法。

完整示例代码如下：

 

1. import java.awt.EventQueue;  
2. import javax.swing.JFrame;  
3. import javax.swing.JPanel;  
4. import java.awt.event.WindowListener;  
5. import java.awt.event.WindowEvent;  
6. import java.awt.event.WindowAdapter;  
7.   
8. public class ListenerTest {  
9.   
10.     public static void main(String[] args) {  
11.         EventQueue.invokeLater(new Runnable() {  
12.   
13.             public void run() {  
14.                 AdapterFrame adapterFrame = new AdapterFrame();  
15.                 WindowListener listenerListener = new TerminatorListener();  
16.                 adapterFrame.addWindowListener(listenerListener);  
17.                   
18.                 WindowListener listenerAdapter = new TerminatorAdapter();  
19.                  adapterFrame.addWindowListener(listenerAdapter);  
20.                   
21.                 adapterFrame.addWindowListener(new WindowAdapter() {  
22.   
23.                     public void windowClosing(WindowEvent e) {  
24.                         System.out.println("Terminator--windowClosing");  
25.                     }  
26.                 });  
27.   
28.                 adapterFrame.setVisible(true);  
29.             }  
30.         });  
31.     }  
32. }  
33.   
34. class AdapterFrame extends JFrame {  
35.   
36.     public AdapterFrame() {  
37.         setTitle("AdapterTest");  
38.         setSize(DEFAULT_WIDTH, DEFALUT_HEIGHT);  
39.   
40.         adapterPanel = new JPanel();  
41.   
42.         add(adapterPanel);  
43.     }  
44.     private JPanel adapterPanel;  
45.     public static final int DEFAULT_WIDTH = 300;  
46.     public static final int DEFALUT_HEIGHT = 200;  
47. }  
48.   
49. class TerminatorAdapter extends WindowAdapter {  
50.   
51.     public void windowClosing(WindowEvent e) {  
52.         System.out.println("TerminatorAdapter---windowClosing");  
53.     }  
54. }  
55.   
56. class TerminatorListener implements WindowListener {  
57.   
58.     public void windowClosing(WindowEvent e) {  
59.         System.out.println("TerminatorListener--windowClosing");  
60.     }  
61.   
62.     @Override  
63.     public void windowOpened(WindowEvent e) {  
64.         // throw new UnsupportedOperationException("Not supported yet.");  
65.     }  
66.   
67.     @Override  
68.     public void windowClosed(WindowEvent e) {  
69.         //throw new UnsupportedOperationException("Not supported yet.");  
70.     }  
71.   
72.     @Override  
73.     public void windowIconified(WindowEvent e) {  
74.         //throw new UnsupportedOperationException("Not supported yet.");  
75.     }  
76.   
77.     @Override  
78.     public void windowDeiconified(WindowEvent e) {  
79.         //throw new UnsupportedOperationException("Not supported yet.");  
80.     }  
81.   
82.     @Override  
83.     public void windowActivated(WindowEvent e) {  
84.         //  throw new UnsupportedOperationException("Not supported yet.");  
85.     }  
86.   
87.     @Override  
88.     public void windowDeactivated(WindowEvent e) {  
89.         //  throw new UnsupportedOperationException("Not supported yet.");  
90.     }  
91. }  

运行结果：

关闭AdapterTest窗口，显示结果：

 

1. TerminatorListener--windowClosing  
2. TerminatorAdapter---windowClosing  
3. Terminator--windowClosing