web-dev-qa-db-fra.com

Quelle est la différence entre les auditeurs et les adaptateurs?

J'essaie de faire la différence entre les auditeurs et les adaptateurs.

Sont-ils à peu près les mêmes mais dans les auditeurs, vous devez implémenter toutes les méthodes de l'interface, mais avec les adaptateurs, vous avez la possibilité d'implémenter uniquement les méthodes dont vous avez besoin pour que le code soit plus propre et plus lisible?

On m'a également dit que les adaptateurs permettent l'instanciation avec une seule implémentation et que vous ne pouvez pas instancier les auditeurs, je ne le comprends pas bien.

Quelqu'un peut-il expliquer, s'il vous plaît, lequel est le mieux à utiliser et ce que vous pouvez faire avec l'un mais que vous ne pouvez pas utiliser avec l'autre?

javaswingawtadapterlisteners
21
orange

WindowListener est interface qui vous oblige à override toutes les méthodes, alors que WindowAdapter est l'implémentation de WindowListener et que vous devez seulement override la ou les méthodes que vous souhaitez utiliser.

WindowListener est une interface qui signifie que vous ne pouvez pas instancier la WindowListener, alors que WindowAdapter est une classe concrète que vous pouvez utiliser l'opérateur new pour l'instanciation.

Lorsque vous utilisez WindowAdapter, le code est plus propre, votre classe ne substituant que la ou les méthodes que vous voulez . Par exemple: 

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

Lors de l'utilisation de l'adaptateur, le code est plus propre:

// at JFrame class
addWindowListener(new CloseListener());

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

Ou

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

Je recommanderais donc d'utiliser WindowAdapter, mais pas doit suivre. Cependant, deux des API correspondant à la même chose que WindowAdapter existent pour faciliter la création d’objets d’écoute.

MODIFIER:

Puisque WindowListener est interface, vous pouvez l'implémenter dans votre sous-classe JFrame.

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

Mais vous ne pouvez pas le faire avec WindowAdapter.

31
Pau Kiat Wee

Vous pouvez tout faire avec soit, mais si vous commencez par l'interface, votre code va avoir beaucoup de passe-partout. Je suis sûr que vous avez remarqué cela lorsque vous l'avez essayé. Cette déclaration sur l'instanciation, etc., est une façon assez compliquée de le dire et les termes sont très confus. Tu peux écrire 

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) { }
});

ou vous pouvez écrire

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

Dans les deux cas, vous instanciezWindowListener ou WindowAdapter - vous créez des classes anonymes implémentant WindowListener/extend WindowAdapter. Mais lorsque vous implémentez l'interface directement, vous êtes obligé d'implémenter toutes les méthodes. Lorsque vous étendez la classe d'adaptateur, vous ne pouvez remplacer que ce dont vous avez besoin. Cette classe a déjà exactement ces implémentations vides que vous avez dû écrire dans le cas Listener.

8
Marko Topolnik

Il y a un autre aspect qui n'est pas abordé dans les autres réponses: l'évolution de l'API. Fournir des classes d'adaptateur (implémentations d'interfaces vides ou par défaut, a.k.a) rend moins pénible l'introduction de nouvelles méthodes dans les interfaces. Si une API fournit uniquement des interfaces, les clients sont obligés de les implémenter. Si une nouvelle méthode est ajoutée aux interfaces, toutes les classes d'implémentation sont interrompues. Toutefois, si des implémentations par défaut sont fournies, les clients ont la possibilité d'étendre celles qui, outre leur caractère pratique, les aident à passer à la version la plus récente de l'API. Avec méthodes par défaut de Java 8, les implémentations par défaut/vides sont devenues moins importantes, mais elles pourraient être utiles dans les versions antérieures.

0
Katona

Il existe plusieurs classes d'adaptateur, telles que MouseAdapter, KeyAdapter, WindowAdapter, que l'on peut étendre, évitant ainsi d'écrire les méthodes dont vous n'avez pas besoin.

Le problème avec les interfaces est que vous devez écrire toutes les méthodes dont vous n’avez pas besoin. La classe Adapter peut en outre être classée dans Sub afin de remplacer la méthode requise. 

http://www.cafeaulait.org/course/week7/19.html

0
Arianule

Les écouteurs sont utilisés lorsque vous prévoyez d'utiliser la plupart des méthodes d'interface. Lorsque vous ne devez utiliser que quelques-unes des méthodes, un adaptateur est préférable car vous n'avez pas à remplacer le reste des méthodes.

0
Itchy Nekotorych