Frage zu Exception Handling

[Mane123]

Hallo zusammen,

ich habe für eine Aufgabe folgendes Programm erstellt:

import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.text.DecimalFormat;


import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JTextField;
import javax.swing.border.TitledBorder;

public class TaschenrechnerGUIV2 extends JFrame{

	//automatisch über Eclipse eingefügt
	private static final long serialVersionUID = 3006212012028893840L;
	
	//die Komponente
	//zwei Eingabefelder
	private JTextField eingabe1, eingabe2;
	//die vier Rechenarten in einem Array für das Kombinationsfeld
    private	String [] operatoren = {"Addition", "Subtraktion", "Multiplikation", "Division"};
	
    //das Kombinationsfeld für die Rechenoperationen
    private JComboBox auswahlOperatoren;
	
	
	//zwei Schaltflächen
	private JButton schaltflaecheBerechnen, schaltflaecheBeenden;
	//ein Label für die Ausgabe
	private JLabel ausgabe;
	
	//die innere Klasse für die Ereignisverarbeitung
	class MeinListener implements ActionListener, ItemListener {
		
		@Override
		public void actionPerformed(ActionEvent e) {
			//wurde auf Beenden geklickt?
			//dann das Programm beenden
			if (e.getActionCommand().equals("ende")) 
				System.exit(0);
			//wurde auf Berechnen geklickt?
			//dann eine Methode für die Berechnung aufrufen
			//und das Ergebnis anzeigen
			if (e.getActionCommand().equals("rechnen"))  
				ausgabe.setText(berechnen());
		}

		@Override
		public void itemStateChanged(ItemEvent e) {
			// TODO Auto-generated method stub
			Object ausloeser = e.getSource();
			
			if (ausloeser instanceof JComboBox)
			ausgabe.setText(berechnen());
		}
	}
	
	//der Konstruktor
	public TaschenrechnerGUIV2(String titel) {
		
		super(titel);
		
		//insgesamt 4 Panels
		JPanel panelEinAus, panelBerechnung, panelButtons, gross;
		
		//die Panels über die Methoden erstellen
		panelEinAus = panelEinAusErzeugen();
		panelBerechnung = panelBerechnungErzeugen();
		panelButtons = panelButtonErzeugen();
		
		//das Border-Layout benutzen
		//es ist Standard und muss nicht gesetzt werden
		
		//die Panels hinzufügen
		//die beiden größeren Panel fassen wir noch einmal zusammen
		gross = new JPanel();
		gross.add(panelEinAus);
		gross.add(panelBerechnung);
		//die beiden kommen in die Mitte
		add(gross,BorderLayout.CENTER);
		//das Panel mit den Buttons nach rechts
		add(panelButtons, BorderLayout.EAST);

		//die Standard-Aktion setzen
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		//packen und anzeigen
		pack();
		setVisible(true);
		
		//Größenänderungen sind nicht zugelassen
		//damit das mühsam erstellte Layout nicht durcheinander kommt
		setResizable(false);
	}

	//die Methode erzeugt das Panel für die Ein- und Ausgabe
	//und liefert es zurück
	private JPanel panelEinAusErzeugen() {
		JPanel tempPanel = new JPanel();
		//es enthält die Eingabefelder mit beschreibendem Text und die Ausgabe
		//die Länge der Felder ist auf 10 Zeichen beschränkt
		eingabe1 = new JTextField(10);
		eingabe2 = new JTextField(10);
		ausgabe = new JLabel("");
		
		//das Panel bekommt ein GridLaoyut mit 2 Spalten und etwas Abstand
		tempPanel.setLayout(new GridLayout(0,2,10,10));
		//ein beschreibendes Label für die erste Eingabe
		tempPanel.add(new JLabel("Zahl 1:"));
		//das erste Eingabefeld
		tempPanel.add(eingabe1);
		
		//und jetzt das zweite Eingabefeld
		tempPanel.add(new JLabel("Zahl 2: "));
		tempPanel.add(eingabe2);
		
		//und nun das Ausgabefeld für das Ergebnis
		tempPanel.add(new JLabel("Ergebnis: "));
		tempPanel.add(ausgabe);
		
		//einen Rahmen um das Panel ziehen
		tempPanel.setBorder(new TitledBorder("Ein- und Ausgabe"));
		
		//das Panel zurückliefern
		return tempPanel;
	}
	
	//die Methode erzeugt das Panel für die Auswahl
	//der Rechenoperation und liefert es zurück
	private JPanel panelBerechnungErzeugen() {
		JPanel tempPanel = new JPanel();
		//es enthält das Kombinationsfeld mit den Rechenoperationen
		
		auswahlOperatoren = new JComboBox(operatoren);
		
		tempPanel.add(auswahlOperatoren);
		
		
		
		//das Panel bekommt ein GridLaoyut mit 1 Spalte
		tempPanel.setLayout(new GridLayout(0,1));
	
		
		//und einen Rahmen
		tempPanel.setBorder(new TitledBorder("Operation: "));

		//das Panel zurückliefern
		return tempPanel;
	}
	
	//die Methode erzeugt das Panel für die Schaltflächen
	//und liefert es zurück
	private JPanel panelButtonErzeugen() {
		JPanel tempPanel = new JPanel();

		schaltflaecheBeenden = new JButton(" Beenden ");
		//das Aktion-Command setzen
		schaltflaecheBeenden.setActionCommand("ende");
		schaltflaecheBerechnen = new JButton("Berechnen");
		schaltflaecheBerechnen.setActionCommand("rechnen");
		
		//Zwischenpanel für die Schaltflächen
		//ebenfalls ein GridLayout
		tempPanel.setLayout(new GridLayout(0,1));
		tempPanel.add(schaltflaecheBerechnen);
		//ein leeres Label einfügen
		tempPanel.add(new JLabel());
		tempPanel.add(schaltflaecheBeenden);
		
		//die Schaltflächen mit dem Listener verbinden
		MeinListener listener = new MeinListener();
		schaltflaecheBeenden.addActionListener(listener);
		schaltflaecheBerechnen.addActionListener(listener);
		auswahlOperatoren.addItemListener(listener);
		
		//das Panel zurückliefern
		return tempPanel;
	}
	
	//die Methode berechnet das Ergebnis und liefert es als 
	//Zeichenkette zurück
	private String berechnen() {
		//ergebnis muss initialisiert werden
		double zahl1, zahl2, ergebnis = 0;
		boolean fehlerFlag = false;
	
		//jetzt mit Fehlerbehandlung und Ausgabe der Meldung durch eine eigene Methode
		try {
			zahl1 = Double.parseDouble(eingabe1.getText());
		}
		catch (Exception NumberFormatException) {
			fehlermeldung(eingabe1);
			return ("Nicht definiert");
		}
		
		try {
			zahl2 = Double.parseDouble(eingabe2.getText());
		}
		catch (Exception NumberFormatException) {
			fehlermeldung(eingabe2);
			//das Ergebnis ist nicht definiert
			return ("Nicht definiert");
		}
		//welche Operation soll durchgeführt werden?
		//Addition = Index 0
		if (auswahlOperatoren.getSelectedIndex() == 0)
			ergebnis = zahl1 + zahl2;
		
		if (auswahlOperatoren.getSelectedIndex() == 1)
			ergebnis = zahl1 - zahl2;
		
		if (auswahlOperatoren.getSelectedIndex() == 2)
			ergebnis = zahl1 * zahl2;
		//bei der Division überprüfen wir den zweiten Wert auf 0
		
		if (auswahlOperatoren.getSelectedIndex() == 3) {
			if (zahl2 != 0)
				ergebnis = zahl1 / zahl2;
			else 
				fehlerFlag = true;
		}
		
		//wenn es keine Probleme gegeben hat, liefern wir das Ergebnis zurück
		if (fehlerFlag == false) {
			//die Formatvorgabe über die Klasse DecimalFormat
			DecimalFormat formatFolge = new DecimalFormat("0.##");
			//das Format anwenden, das Ergebnis ist eine Zeichenkette
			return (formatFolge.format(ergebnis));
		}
		else
			return ("Nicht definiert");
	}
	
	private void fehlermeldung(JTextField eingabefeld) {
		JOptionPane.showMessageDialog(this, "Ihre Eingabe ist nicht gültig","Eingabefehler", JOptionPane.ERROR_MESSAGE);
		eingabefeld.requestFocus();
	}
	
}

Zu Beginn ist der Operator "Addition" markiert. Wenn man auf den Button "Berechnen" klickt, dann wird beim ersten Mal eine Addition durchgeführt.
Wird nun in dem Kombinationsfeld eine andere Operation ausgewählt, wird diese automatisch durchgeführt, es muss nicht mehr extra auf Berechnen geklickt werden.

Werden nun ungültige Zeichen eingegeben, dann wird dies über eine NumberFormatException abgefangen.

Wird z.B. bei der ersten Operation "Addition" auf Berechnen geklickt, erscheint die Fehlermeldung einmal. (was auch so gewollt ist)
Wählt man nun einen anderen Operator aus, dann erscheint die Fehlermeldung zweimal.

Könnt ihr mir bitte helfen, warum dies so ist und wie ich das abändern kann?

Vielen Dank!

Viele Grüße!

 

[eRaaaa]

Weil 2 x itemStateChanged aufgerufen wird..wieso benutzt du überhaupt dafür den ItemListener? Benutze doch da auch einfach die actionPerformed..

    class MeinListener implements ActionListener {

	@Override
	public void actionPerformed(ActionEvent e) {
	    // wurde auf Beenden geklickt?
	    // dann das Programm beenden
	    if (e.getActionCommand().equals("ende"))
		System.exit(0);
	    // wurde auf Berechnen geklickt?
	    // dann eine Methode für die Berechnung aufrufen
	    // und das Ergebnis anzeigen
	    else
		ausgabe.setText(berechnen());
	}
    }

Unbd in Zeile 181 addest du auf die Combobox auch den ActionListener anstatt einen ItemListener!

auswahlOperatoren.addActionListener(listener);

 

[Mane123]

Danke für die Antwort!

Wie meinst Du, dass ItemStateChanged 2x aufgerufen wird? Wo erkennt man das denn?

Ich soll den ItemListener verwenden, weil es in der Aufgabenstellung heißt:

Sobald ein anderer Eintrag in dem Kombinationsfeld ausgewählt wurde, soll die Rechnung sofort ausgeführt werden.

Viele Grüße

 

[eRaaaa]

Es wird einmal für das Deselektieren des alten Items und einmal für das Selektieren des neuen Items ein Event gefeuert!
Okay, wenn du unbedingt den iIemListener benutzen musst, kannst du auch eine Abfrage vorher rein machen ala

	    public void itemStateChanged(ItemEvent e) {
		if (e.getStateChange() == ItemEvent.SELECTED) { // <-- NEU
		    Object ausloeser = e.getSource();

		    if (ausloeser instanceof JComboBox)
			ausgabe.setText(berechnen());
		}
	    }

Bzw: wenn das so in der Aufgabe steht, bedeutet es doch nicht dass du einen ItemListener benutzen MUSST ? Mit dem actionListener so wie ich es oben geschrieben habe, geht das doch genauso ?!?!

:rtfm:How to Use Combo Boxes (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Swing Components)

 

[Mane123]

Danke, jetzt läuft es schon mal.

Wenn ich den ActionListener so schreibe, wie du es vorgibst, dann kann ich doch den Button "Berechnen" nicht mehr verwenden?

Es steht weiterhin in der Aufgabe geschrieben:

Sorgen Sie bei der Ereignisverarbeitung dafür, dass überprüft wird, welche Komponente das Ereignis ausgelöst hat.

Was ist damit gemeint? Die Üerprüfung im ItemListener?

Viele Grüße

 

[eRaaaa]

Wenn ich den ActionListener so schreibe, wie du es vorgibst, dann kann ich doch den Button "Berechnen" nicht mehr verwenden?

Klar wieso nicht? (mein Code war zwar nur so mal eben schnell dahin gepostet, funktionieren sollte er dennoch)

Es steht weiterhin in der Aufgabe geschrieben:

Sorgen Sie bei der Ereignisverarbeitung dafür, dass überprüft wird, welche Komponente das Ereignis ausgelöst hat.

Was ist damit gemeint? Die Üerprüfung im ItemListener?

Also ich würde antworten:

Nö, für mich klingt das eher danach, dass du wie ich schon gesagt habe eben nur einen Listener benutzen sollst, nämlich einen ActionListener und in der actionPerformed halt unterscheiden sollst, ob das Event nun durch den Button oder durch die ComboBox ausgelöst wurde...

Aber das ist auch nur eine Meinung von vielen ?!?!

/edit: Was hat das eig. mit Exception Handling zu tun?
/edit2: Vllt postest du mal die komplette Aufgabenstellung . Weil wirklich Sinn machts jetzt so nicht meiner Meinung nach

 

[Mane123]

Ich hab den Action Listener jetzt wie folgt umgeschrieben:

@Override
		public void actionPerformed(ActionEvent e) {
			//wurde auf Beenden geklickt?
			//dann das Programm beenden
			if (e.getActionCommand().equals("ende")) 
				System.exit(0);
			//wurde auf Berechnen geklickt?
			//dann eine Methode für die Berechnung aufrufen
			//und das Ergebnis anzeigen
			if (e.getActionCommand().equals("rechnen"))  
				ausgabe.setText(berechnen());
			
			else
				ausgabe.setText(berechnen());
		}

Jetzt stimmt alles.

Ich habe den Thread so genannt, weil mir eben die doppelte Fehlermeldung beim Exception Handling aufgefallen ist

Woher weiß ich denn, welchen Listener ich verwenden muss?

Bei Check - Box oder Radio Buttons werden ja keine Action Listener "abgefeuert"?

Woran hast du z.B. hier gewusst, dass ein Action Listener zu verwenden ist, und kein Item Listener?
Gibt's da irgendwelche Vor - oder Nachteile?

Viele Grüße

 

[eRaaaa]

Woher weiß ich denn, welchen Listener ich verwenden muss?

Kommt eben auf den Anwendungsfall drauf an, meist hilft es sich einige Beispiele anzuschauen(siehe nächster Link z.B.) oder sich auch mal die API durch zu lesen.

Bei Check - Box oder Radio Buttons werden ja keine Action Listener "abgefeuert"?

???:L - How to Use Buttons, Check Boxes, and Radio Buttons (The Java™ Tutorials > Creating a GUI With JFC/Swing > Using Swing Components)

Woran hast du z.B. hier gewusst, dass ein Action Listener zu verwenden ist, und kein Item Listener?
Gibt's da irgendwelche Vor - oder Nachteile?

Gewusst habe ich hier gar nichts - kenne ja noch nicht mal die exakte Aufgabenstellung. Das mit der Überprüfung macht meiner Meinung ja auch nur Sinn wenn die Komponenten unterschiedliche Aufgaben haben, hier "scheint zumindest so" haben sie ja die Gleiche, du rufst ja auch in beidne Fällen berechnen() auf usw.

            if (e.getActionCommand().equals("rechnen"))  
                ausgabe.setText(berechnen());
            
            else
                ausgabe.setText(berechnen());

daher ist das irgendwie fragwürdig ...aber die genaue Aufgabenstellung kennst du ja :bae:

 

[Mane123]

Danke, ich les mir den Link in der Früh mal durch, bin dafür jetzt schon zu müde

Das mit den Action und ItemListener haber wir bis jetzt noch nicht so richtig durchgenommen. Ich hoffe das kommt noch. Hatten bis jetzt nur 1 Beispiel mit dne ItemListener.

Die genaue Aufgabenstellung:

Erstellen Sie einen Taschenrechner, so, dass die Auswhal der Rechenoperationen nicht über eine Gruppe von Optionsfeldern erfolgt, sondern über ein Kombinationsfeld.

Dabei gelten folgende Vorgaben:

1.:
Erstellen Sie eine Liste für das Kombinationsfeld über ein Array

2.:
Ermitteln Sie die Rechenart, die ausgeführt werden soll, direkt über den Indes des ausgewählten Eintrag in der Liste des Kombinationsfeldes

3.;
Sobal ein anderer Eintrag in dem Kombinationsfeld ausgewählt wurde, soll die Rechnung sofort ausgeführt werden.

4.:
Sorgen Sie bei der Ereignisverarbeitung dafür, dass überprüft wird, welche Komponente das Ereignis ausgelöst hat.


Also die Punkte 1 bis 3 sollten erledigt sein.

Bei dem 4. bin ich mir nicht sicher, was damit genau gemeint ist??


Was meinst Du mit fragwürdig?

Viel Grüße

 

[eRaaaa]

Was meinst Du mit fragwürdig?

Naja, wirklich Sinn macht die Abfrage da ja nicht, da egal ob die nun true oder false liefert, eh das gleiche gemacht wird.
Daher könntest du dir ja eig. die Abfrage direkt schenken...

Was "er/sie" jetzt bei Punkt 4 haben möchte, da bin ich auch überfragt, es sei denn die Aufgabe basiert noch auf einer anderen Aufgabe oder so...funktionieren tut`s ja schließlich auch so...(das man zwischen dem Ende-Button unterscheidet macht ja noch Sinn..)

 

[Mane123]

Hallo!

Die Aufgabe basiert schon auf einer anderen Aufgabe, ich poste hier mal den Ausgangs-Quelltext:

import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
import javax.swing.JTextField;
import javax.swing.border.TitledBorder;

public class TaschenrechnerGUI extends JFrame{

	//automatisch über Eclipse eingefügt
	private static final long serialVersionUID = 3006212012028893840L;
	
	//die Komponente
	//zwei Eingabefelder
	private JTextField eingabe1, eingabe2;
	//vier RadioButtons und eine Gruppe
	private JRadioButton addition, subtraktion, multiplikation, division;
	//zwei Schaltflächen
	private JButton schaltflaecheBerechnen, schaltflaecheBeenden;
	//ein Label für die Ausgabe
	private JLabel ausgabe;
	
	//die innere Klasse für die Ereignisverarbeitung
	class MeinListener implements ActionListener {
		
		@Override
		public void actionPerformed(ActionEvent e) {
			//wurde auf Beenden geklickt?
			//dann das Programm beenden
			if (e.getActionCommand().equals("ende")) 
				System.exit(0);
			//wurde auf Berechnen geklickt?
			//dann eine Methode für die Berechnung aufrufen
			//und das Ergebnis anzeigen
			if (e.getActionCommand().equals("rechnen")) { 
				ausgabe.setText(berechnen());
			}
		}
	}
	
	//der Konstruktor
	public TaschenrechnerGUI(String titel) {
		
		super(titel);
		
		//insgesamt 3 Panels
		JPanel panelEinAus, panelBerechnung, panelButtons;
		
		//die Panels über die Methoden erstellen
		panelEinAus = panelEinAusErzeugen();
		panelBerechnung = panelBerechnungErzeugen();
		panelButtons = panelButtonErzeugen();
		
		//ein Gridlayout mit 3 Spalten
		setLayout(new GridLayout(0,3));
		
		//die Panels hinzufügen
		add(panelEinAus);
		add(panelBerechnung);
		add(panelButtons);

		//die Standard-Aktion setzen
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		
		//packen und anzeigen
		pack();
		setVisible(true);
		
		//Größenänderungen sind nicht zugelassen
		//damit das mühsam erstellte Layout nicht durcheinander kommt
		setResizable(false);
	}

	//die Methode erzeugt das Panel für die Ein- und Ausgabe
	//und liefert es zurück
	private JPanel panelEinAusErzeugen() {
		JPanel tempPanel = new JPanel();
		//es enthält die Eingabefelder mit beschreibendem Text und die Ausgabe
		//die Länge der Felder ist auf 10 Zeichen beschränkt
		eingabe1 = new JTextField(10);
		eingabe2 = new JTextField(10);
		ausgabe = new JLabel("");
		
		//das Panel bekommt ein GridLaoyut mit 2 Spalten und etwas Abstand
		tempPanel.setLayout(new GridLayout(0,2,10,10));
		//ein beschreibendes Label für die erste Eingabe
		tempPanel.add(new JLabel("Zahl 1:"));
		//das erste Eingabefeld
		tempPanel.add(eingabe1);
		
		//und jetzt das zweite Eingabefeld
		tempPanel.add(new JLabel("Zahl 2: "));
		tempPanel.add(eingabe2);
		
		//und nun das Ausgabefeld für das Ergebnis
		tempPanel.add(new JLabel("Ergebnis: "));
		tempPanel.add(ausgabe);
		
		//einen Rahmen um das Panel ziehen
		tempPanel.setBorder(new TitledBorder("Ein- und Ausgabe"));
		
		//das Panel zurückliefern
		return tempPanel;
	}
	
	//die Methode erzeugt das Panel für die Auswahl
	//der Rechenoperation und liefert es zurück
	private JPanel panelBerechnungErzeugen() {
		JPanel tempPanel = new JPanel();
		//es enthält die Gruppe mit den Optionsfeldern
		addition = new JRadioButton("Addition");
		subtraktion = new JRadioButton("Subtraktion");
		division = new JRadioButton("Division");
		multiplikation = new JRadioButton("Multiplikation");
		
		ButtonGroup gruppe = new ButtonGroup();
		gruppe.add(addition);
		gruppe.add(subtraktion);
		gruppe.add(multiplikation);
		gruppe.add(division);
		
		//die Addition ist ausgewählt
		addition.setSelected(true);
		
		//das Panel bekommt ein GridLaoyut mit 1 Spalte
		tempPanel.setLayout(new GridLayout(0,1));
		tempPanel.add(addition);
		tempPanel.add(subtraktion);
		tempPanel.add(multiplikation);
		tempPanel.add(division);
		
		//und einen Rahmen
		tempPanel.setBorder(new TitledBorder("Operation: "));

		//das Panel zurückliefern
		return tempPanel;
	}
	
	//die Methode erzeugt das Panel für die Schaltflächen
	//und liefert es zurück
	private JPanel panelButtonErzeugen() {
		JPanel tempPanel = new JPanel();
		

		schaltflaecheBeenden = new JButton(" Beenden ");
		//das Aktion-Command setzen
		schaltflaecheBeenden.setActionCommand("ende");
		schaltflaecheBerechnen = new JButton("Berechnen");
		schaltflaecheBerechnen.setActionCommand("rechnen");
		
		//Zwischenpanel für die Schaltflächen
		//das Panel wird linksbündig ausgerichtet mit mehr Abstand
		tempPanel.setLayout(new FlowLayout(FlowLayout.LEFT,20,10));
		tempPanel.add(schaltflaecheBerechnen);
		tempPanel.add(schaltflaecheBeenden);
		
		//die Schaltflächen mit dem Listener verbinden
		MeinListener listener = new MeinListener();
		schaltflaecheBeenden.addActionListener(listener);
		schaltflaecheBerechnen.addActionListener(listener);
		
		//das Panel zurückliefern
		return tempPanel;
	}
	
	//die Methode berechnet das Ergebnis und liefert es als 
	//Zeichenkette zurück
	private String berechnen() {
		//ergebnis muss initialisiert werden
		//obwohl es in jedem Fall einen Wert bekommt
		//das kann der Compiler aber nicht erkennen :)
		double zahl1, zahl2, ergebnis = 0;
		//für die Steuerung der Rückgabe
		boolean fehlerFlag = false;
		
		//die Werte beschaffen, umformen und zuweisen
		zahl1 = Double.parseDouble(eingabe1.getText());
		zahl2 = Double.parseDouble(eingabe2.getText());
		
		//welche Operation ist ausgewählt?
		if (addition.isSelected())
			ergebnis = zahl1 + zahl2;
		if (subtraktion.isSelected())
			ergebnis = zahl1 - zahl2;
		if (multiplikation.isSelected())
			ergebnis = zahl1 * zahl2;
		//bei der Division überprüfen wir den zweiten Wert auf 0
		if (division.isSelected()) {
			if (zahl2 != 0)
				ergebnis = zahl1 / zahl2;
			else 
				fehlerFlag = true;
		}
		//wenn es keine Probleme gegeben hat, liefern wir das Ergebnis zurück
		if (fehlerFlag == false)
			return Double.toString(ergebnis);
		else
			return ("Nicht definiert");
	}
}

Was ist denn dann mit Punkt 4 gemeint?
Welchen Sinn hat es hier zu prüfen, welche Komponente das Ereignis ausgelöst hat?

Viele Grüße