Qual è la differenza tra addActionListener(this) e addActionListener(new ActionListener)?

Voglio aggiungere la gestione degli eventi per i pulsanti – e ho notato che ci sono due modi per fare questo.

  1. Implementa l’interfaccia ActionListener e poi aggiungere listener di eventi per i pulsanti.

Esempio:

countButton.addActionListener(this);

E nel metodo ActionPerformed verrà eseguito per visualizzare il risultato.

  1. Non si implementa l’interfaccia ActionListener e al posto di fare questo:
    countButton.addActionListener(new ActionListener() {
    
        public void actionPerformed(ActionEvent e)
        {
            //Execute when button is pressed
            System.out.println("You clicked the button");
        }
    });  

Come fa il secondo metodo funziona esattamente?????!!!

Grazie!

  • Fa la stessa cosa, tranne che il secondo è un anonymous inner class.
InformationsquelleAutor alan | 2011-09-15

 

5 Replies
  1. 3

    Non è necessario definire una seconda classe per il primo approccio. Hai solo bisogno di aggiungere il

    public void actionPerformed(ActionEvent e) metodo all’interno della classe e fare quello che vuoi lì, dopo aver effettuato la classe implementa ActionListener. Si potrebbe utilizzare una seconda classe, se si voleva, ma non è necessario. Lo svantaggio è che è necessario specificare l’origine dell’evento con lunghi se le istruzioni per prendere l’azione appropriata se si dispone di più di un JButtons cioè

    Il secondo approccio è l’aggiunta di un anonimo interiore ActionListener per ogni componente. Si tratta di un approccio Object Oriented, dal momento che si dispone di una chiara separazione delle funzionalità del vostro widget. È un vantaggio per definire un ulteriore metodo di chiamata all’interno di ogni actionPerformed, al fine di essere in grado di utilizzare questo liberamente e fare riferimento alla classe che lo contiene:

    countButton.addActionListener(new ActionListener() {
        public void actionPerformed(ActionEvent e) {
            doCountButtonAction(e);
            //"this" here would refer to the ActionListener (not that useful)
        }
    }); 

    e implementare il metodo:

    private void doCountButtonAction(ActionEvent e) {
       //do whatever you need to here
       //using "this" here refers to the containing class (i.e. JFrame, JPanel or whatever)
    }
  2. 1

    La tua domanda non è esattamente sulla ascoltatori come è su come le interfacce di lavoro e di come è possibile creare un’istanza di una classe in Java. Ecco alcuni dei punti più delicati:

    1. Sostanzialmente, che la classe JButton offre è un modo per dichiarare una classe che è uno in particolare che metodo viene richiamato quando un evento viene attivato il pulsante, come quando si fa clic. Se si guarda il Javadoc per JButton e ActionListener, ora come funzionano:

    http://download.oracle.com/javase/1.4.2/docs/api/javax/swing/AbstractButton.html#addActionListener(java.awt.event.ActionListener)

    http://download.oracle.com/javase/1.4.2/docs/api/java/awt/event/ActionListener.html

    Cosa si può fare qui, nella maggior parte vecchia maniera possibile è creare una classe che viene attivato quando qualcuno fa clic sul tuo pulsante:

    public class MyButtonActionListener implements ActionListener {
    
    actionPerformed(ActionEvent e) {    
        System.out.println("Aww, you clicked!");    
        }
    }

    Ora, e una volta fatto, è possibile effettuare una insance di esso e aggiungere un listener per il pulsante:

    JButton button = new JButton("My button");

    MyButtonActionListener myActionListener = new MyButtonActionListener ();
    il pulsante.addActionListener(myActionListener);

    D’altra parte, in Java è possibile creare un’istanza di una classe anonimousy, il che significa che invece di avere un gestore di istanza (come myActionListener nel codice di cui sopra), basta creare un’istanza al volo nel punto in cui si ha bisogno, e non avrai nessun gestore di utilizzarlo in seguito. Ciò che accade nel tuo codice: un ActionListener attuazione è delcared al volo come parametro per il metodo addActionListener, che al volo di dichiarazione comprende anche la dichiarazione che il tuo anonimo istanza non è solo una classe qualsiasi, ma uno che implementa ActionListener, e ad anonimi dichiarazione deve fornire un’implementazione del metodo actionPerformed.

    Una terza opzione è quella di avere una classe che implementa ActionListener (e il metodo actionPerformed), e all’interno di quella classe, se si crea un JButton e si desidera passare come ascoltatore un’istanza della ecompasing classe, potrete usare “questo” per reffer, come in :

    public class MyButtonActionListener implements ActionListener {
    
    private JButton button = new JButton();
    
    
    public void init() {
        button.addActionListener(this);
    }
    
    public actionPerformed(ActionEvent e) {
        System.out.println("u clicked!");
        }
    }

    Ci sono un sacco di punti più fini di questa discussione (come in come si fa a reffer per il “si” in un n classe anonima delcared all’interno di un’altra classe, e come si fa a reffer per il “si” dell’comprende istanza di classe). Si consiglia di leggere un libro sulla certificazione Sun Certified Java Programmer, che ha un capitolo dedicato a questo

  3. 0

    Che crea un anonimo classe che implementa il metodo actionPerformed. In questo modo non è necessario definire una nuova classe per ogni luogo che si desidera gestire un evento.

  4. 0

    Funziona allo stesso modo come la prima tecnica vale a dire Il metodo si aspetta un oggetto che implementa ActionListener interfaccia. Tuttavia, entrambe le tecniche ha i suoi meriti e demeriti. La prima è una tecnica che permette utilizzando il singolo oggetto a spese dell’ingombro if/else codice stesso metodo sarà la gestione di eventi per i più pulsanti. La seconda tecnica permette di pulitura separazione della logica per ogni pulsante spese di creare più oggetti anonimi (per ogni pulsante).

  5. 0

    In ogni modo, per aggiungere un ActionListener avete bisogno di una classe che implementa l’interfaccia ActionListener (che definisce un metodo unico, actionPerformed). addActionListener(this) implica che this implementa tale interfaccia, e qualsiasi azione eseguita chiamerà this.actionPerformed.

    Nel secondo caso, quello che stai facendo è la creazione di un nuovo, anonimo, di una classe che implementa l’interfaccia ActionListener. Quando countButton viene cliccato, il actionPerformed metodo chiamato è quello in classe anonima.

Lascia un commento