Eventhandler: innere Klassen vs. "normale Klassen"

[AKST]

Vielleicht ist dieser Stil doch ganz gut:

jbOK.addActionListener(new java.awt.event.ActionListener(){
			
  public void actionPerformed(ActionEvent e){
    jbOK_actionPerformed(e);
  }
});

jbCancel.addActionListener(new java.awt.event.ActionListener(){

  public void actionPerformed(ActionEvent e){
    jbCancel_actionPerformed(e);
  }
});

 

[Snape]

Bestimmt ist der gut.
Ich/Wir implementiere fast nur so.

 

[Thomas Darimont]

Hallo!

jbOK.addActionListener(new java.awt.event.ActionListener(){
			
  public void actionPerformed(ActionEvent e){
    jbOK_actionPerformed(e);
  }
});

jbCancel.addActionListener(new java.awt.event.ActionListener(){

  public void actionPerformed(ActionEvent e){
    jbCancel_actionPerformed(e);
  }
});

... für jede Componente eine eigene Anonyme Klasse UND noch eine Methode für jede Componente ...?!

Also wenns bei mir mehr als 5 Componenten gibt die auf ActionEvents
reagieren sollen dann erstelle ich lieber eine Inner Klasse die das ActionListener Interface implementiertt. Dort sieht das weitere dann Ungefähr so aus:

import java.awt.Component;
import java.awt.Container;
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

public class EventHandlingDemo extends JFrame {

	private JButton btnOk, btnCancel, btnExit, btnAction0, btnAction1;

	public EventHandlingDemo() {
		super("EventHandlingDemo");
		setDefaultCloseOperation(EXIT_ON_CLOSE);

		Container c = getContentPane();
		c.setLayout(new FlowLayout());

		final ActionListener listener = new ActionHandler();

		c.add((btnOk = new JButton("btnOk") {
			{
				addActionListener(listener);
			}
		}));

		c.add((btnCancel = new JButton("btnCancel") {
			{
				addActionListener(listener);
			}
		}));
		c.add((btnExit = new JButton("btnExit") {
			{
				addActionListener(listener);
			}
		}));
		c.add((btnAction0 = new JButton("btnAction0") {
			{
				addActionListener(listener);
			}
		}));
		c.add((btnAction1 = new JButton("btnAction1") {
			{
				addActionListener(listener);
			}
		}));

		pack();
		setVisible(true);
	}

	public static void main(String[] args) {
		new EventHandlingDemo();
	}

	class ActionHandler implements ActionListener {

		public void actionPerformed(ActionEvent e) {
			Object o = e.getSource();
			
			if(o == btnOk){ 
				JOptionPane.showMessageDialog((Component)o,"btnOk was pressed!");
			}else if(o == btnCancel){
				JOptionPane.showMessageDialog((Component)o,"btnCancel was pressed!");
			}else if(o == btnExit){
				JOptionPane.showMessageDialog((Component)o,"btnExit was pressed!");
			}else if(o == btnAction0){
				JOptionPane.showMessageDialog((Component)o,"btnAction0 was pressed!");
			}else if(o == btnAction1){
				JOptionPane.showMessageDialog((Component)o,"btnAction1 was pressed!");
			}
		}
	}
}

So habe ich meinen Event Code schön übersichtlich an einer Stelle und muß mir nicht 10 Mio. Methoden durchschauen...

Gruß Tom

 

[Christian Fein]

Original geschrieben von Thomas Darimont


So habe ich meinen Event Code schön übersichtlich an einer Stelle und muß mir nicht 10 Mio. Methoden durchschauen...

Finde ich nicht so schön. Wenn du z.b einerseits den Button Save und anderseits den Menupunkt Save hast, kannst du nicht einfach eine SavePressedListener ohne codezugriff zuordnen.

Meiner Meinung nach besser

  public class SaveActionListener extends ActionListener() {
     public void actionPerformed(ActionEvent e){
        // speichern
      }
  }

 ... 
    menuSave.addActionListener(new SaveActionListener());
    buttonSave.addActionListener(new SaveActionListener());

 

[Thomas Darimont]

Kommt darauf an...

wenn der Codeanteil der hinter ActionPerformed des jeweiligen Controls liegt in exorbitante Dimensionen ansteigt ist es natürlich besser eine eigene Klasse dafür zu kreieren. Falls jedoch nur 2-3 Anweisungen abzuarbieten sind finde ich den Innere Klassen Ansatz besser.

Gruß Tom

 

[Christian Fein]

Original geschrieben von Thomas Darimont
Kommt daruf an...

wenn der Codeanteil der hinter ActionPerformed des jeweiligen Controls liegt in exorbitante Dimensionen ansteigt ist es natürlich besser eine eigene Klasse dafür zu kreieren. Falls jedoch nur 2-3 Anweisungen abzuarbieten sind finde ich den Innere Klassen Ansatz besser.

Gruß Tom

Womit meine 1. Aussage in diesem Thread wieder passen würde

Das kommt auf die Situation, grösse des Projektes, usw an.

*ich muss das letzte Wort haben*

 

[AKST]

Thomas seine Lösung ist doch ähnlich zu meiner. Er fragt innerhalb einer ActionListener-Klasse die aufrufende Klasse (JButton1, JButton2...) ab und ordnet dann die Methode zu.
Ich muss ehrlich sagen, dass es mir nicht wirklich einleuchten will, dass es übersichtlicher ist jedem Oberflächenelement einen extra ActionListener
zu spendieren als mehrere Buttons in einem Listener zu bearbeiten. Da man ja in ActionListenern so wenig Code wie möglich schreiben soll (es werden nur Methoden aufgerufen), ist es doch garnicht so verkehrt das in einer Klasse zu machen (sei es nun eine innere, oder äußere Klasse).

P.S. ich als Java-newbie lasse mich aber gerne eines besseren belehren....