What is the difference between listeners and adapters?

Question

I'm trying to differentiate between listeners and adapters.

Are they pretty much the same but in listeners you have to implement all the methods in the interface, but with adapters you have an option to only implement the methods you need so the code is cleaners and easier to read?

I also got told that adapters enable instantiation with only one implementation and you can't instantiate listeners, I don't fully understand this.

Can someone please explain which one is better to use and things you can do with one but you can't with the other?

Answer 1

WindowListener is interface which force you to override all of the methods, while WindowAdapter is implementation of WindowListener and you only need to override the method(s) that you interest to deal with.

WindowListener is interface which mean you cant instantiation the WindowListener, while WindowAdapter is concrete class that you can use new operator to instantiation.

When you use WindowAdapter, the code is more clean where your class only override the method(s) that you want. For example:

WindowListener

public class CloseListener implements WindowListener {     // im not interest  on this event, but still need to override it     @Override     public void windowOpened(WindowEvent e) {      }     // im not interest  on this event, but still need to override it         @Override     public void windowClosing(WindowEvent e) {      }      @Override     public void windowClosed(WindowEvent e) {         System.exit(0);      }     // im not interest  on this event, but still need to override it         @Override     public void windowIconified(WindowEvent e) {      }     // im not interest  on this event, but still need to override it     @Override     public void windowDeiconified(WindowEvent e) {      }  } 

WindowAdapter

While using adapter the code is cleaner:

// at JFrame class addWindowListener(new CloseListener());  // reusable Close Listener public class CloseListener extends WindowAdapter {     @Override     public void windowClosed(WindowEvent e) {         System.exit(0);     } } 

Or

addWindowListener(new WindowAdapter() {     @Override     public void windowClosed(WindowEvent e) {          System.exit(0);      } }); 

So I would recommend to use WindowAdapter, but not must follow. However, two of the API about the same just that WindowAdapter exists as convenience for creating listener objects.

EDIT:

Since WindowListener is interface, you can implement it at your JFrame subclass.

public class MainWindow extends JFrame implements WindowListener {     // this is ok } public class MainWindow extends JFrame, WindowAdapter {     // this is not allow } 

But you cant do it with WindowAdapter.

Answer 2

You can do everything with either, but if you start with the interface, your code is going to have a LOT of boilerplate. I'm sure you noticed that when you tried it out. That statement about instantiation etc. is a quite convoluted way of saying it and there's a lot of confusion of terms. You can write

c.addWindowListener(new WindowListener() {   @Override public void windowActivated(WindowEvent arg0) { }   @Override public void windowClosed(WindowEvent arg0) { System.exit(0); }   @Override public void windowClosing(WindowEvent arg0) { }   @Override public void windowDeactivated(WindowEvent arg0) { }   @Override public void windowDeiconified(WindowEvent arg0) { }   @Override public void windowIconified(WindowEvent arg0) { }   @Override public void windowOpened(WindowEvent arg0) { } }); 

or you can write

c.addWindowListener(new WindowAdapter() {   @Override public void windowClosed(WindowEvent arg0) { System.exit(0); } }); 

In neither case are you instantiating either WindowListener or WindowAdapter—you are creating anonymous classes that implement WindowListener/extend WindowAdapter. But when you implement the interface directly, you are forced to implement all methods, wheras when you extend the adapter class, you can only override what you need. That class already has exactly these empty implementations that you had to write in the Listener case.