有关在Java Swing中使用适配器和侦听器的一些疑问

Question

I am studying Java Swing and the Adapters to handle events but I have some doubts related to the following working example that I am studying:

import java.awt.*;
import java.awt.event.*;

import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.border.TitledBorder;

public class ListenerDemo extends JPanel implements MouseMotionListener{

    // Label che visualizzano la posizione X ed Y del cursore:
    JLabel labelX;
    JLabel labelY;

    public ListenerDemo() {

        /* Add a MouseMotionListener to this object to catch when the user uses the mouse: */
        addMouseMotionListener(this);

        Font f = new Font(Font.SANS_SERIF, Font.PLAIN, 50);

        TitledBorder borderX = new TitledBorder("Mouse X");
        TitledBorder borderY = new TitledBorder("Mouse Y");

        borderX.setTitleJustification(TitledBorder.CENTER);
        borderY.setTitleJustification(TitledBorder.CENTER);

        labelX = new JLabel("0");
        labelX.setBorder(borderX);
        labelY = new JLabel("0");
        labelY.setBorder(borderY);

        labelX.setFont(f);
        labelY.setFont(f);
        super.add(labelX);
        super.add(labelY);

    }

    // NOT IMPLEMENTED:
    public void mouseDragged(MouseEvent e) {}

    // IMPLEMENTED:
    public void mouseMoved(MouseEvent e) {
         labelX.setText("X : "+e.getX());
         labelY.setText("Y : "+e.getY());
    }


    public static void main(String [] argv) {

        // WindowsAdapter che implementa solo il metodo WindowClosing()
        WindowAdapter adpt = new WindowAdapter() {
            /*
             * Alla chiusura della finestra ripassa il focus al frame principale.
             * @param A low-level event that indicates that a window has changed its status
             */
            public void windowClosing(WindowEvent e) {
                System.exit(0);
            }
        };

        JFrame frame = new JFrame("ListenerDemo");  // Frame esterno

        // Add at the frame ONLY the anonymous adapter WindowAdapter class:
        frame.addWindowListener(adpt);

        // Add to the ContentPane inside the frame the ListenerDemo listener:
        frame.getContentPane().add(new ListenerDemo(), null);

        // Display the window:
        frame.pack();
        frame.setVisible(true);
        frame.setExtendedState(JFrame.MAXIMIZED_BOTH);
    }
}

I have some difficulties to understand the logic of this program:

The first doubt is Why the **ListenerDemo class extendes JPanel and implements MouseMotionListener ?

I think that the logic of the program is the following one:

Inside the main() method I create a new WindowAdapter object that is an instance of the WindowAdapter that allows me to implement only some methods that handle events related to my WindowEvent events. So, using this adapter, I can avoid implementing some listener methods that do not interest me. In this case the WindowAdapter implement only the moethod related to the closoure of a window and not implement others windows events.

Is this reasoning correct?

Following the example shows the difference with the concept of using the classic listener in which I have to implement all the method that handle all the events related to a specific listener.

In this example, in my main(), I add a custom ListenerDemo to the content of the frame and I think that this listener add a addMouseMotionListener to the current object by this line:

addMouseMotionListener(this);

So I have a listener that catch all the events related to the use of the mouse in the content of my frame.

In this case, because I am using listener, I have to implement both the methods of the MouseMotionListener listener: addMouseMotionListener and removeMouseMotionListener

Is it correct?

I have another doubt: it seems to me that this coding style is pretti orrible (but maybe it is only my impression because I don't know it) because it do all in a single class, can I separate it in a better way?

Tnx

Andrea

Answer 1

Your ListenerDemo is a graphical user interface, so that's why it extends JPanel : that way it inherits all graphical properties of a default panel.

In my opinion, it is bad practice that ListenerDemo also implements MouseMotionListener . It is a misuse of the adapter pattern. So what is that pattern?

In short: in ListenerDemo you have some code:

labelX.setText("X : "+e.getX());
labelY.setText("Y : "+e.getY());

which you want to wire to an event of the panel: when the mouse is moved.

The typical adapter pattern uses an anonymous inner class for this:

public ListenerDemo() {

    addMouseMotionListener(new MouseMotionListener() {
        // NOT IMPLEMENTED:
        public void mouseDragged(MouseEvent e) {}

        // IMPLEMENTED:
        public void mouseMoved(MouseEvent e) {
            labelX.setText("X : "+e.getX());
            labelY.setText("Y : "+e.getY());
        }
    });

    // remaining code
}

The effect is the very same, but in my opinion it is awkward to make ListenerDemo implement MouseMotionListener . No other external class needs to know that your demo can capture mouse events, so it should be hidden in its implementation.

Answer 2

The *Adapter classes are just helpful stubs that provide empty implementations for every method of the implementing interface. You can use them, if you do not want to implement all methods - like in your example where you're only interested in the window-closing event.

It is a very common practice that the class that realizes your UI also implements the event handler interface(s). That's mainly because it's convenient, but in fact it's bad style ! Your ListenerDemo needs the listener only internally, so it is not a good idea to add it to the public API of the class. (You don't want users of your class to use it somewhere as a MouseMotionListener , do you?)

So it's much better to have a anonymous inner class that either implements MouseMotionListener or derives from MouseAdapter :

private final MouseMotionListener mouseListener = new MouseAdapter() {
    public void mouseMoved(MouseEvent e) {
        labelX.setText("X : "+e.getX());
        labelY.setText("Y : "+e.getY());
    }
}

Now, in the constructor you can register mouseListener instead of this .

Concerning your question about separation: You should/could move the main method out into a separate 'Main' class.