actionListener für Button

[LouCyphre]

    @Override
    public void actionPerformed(ActionEvent event) {

    
        if(event.getSource()==plusButton) {


            num1 = Double.parseDouble(textfeld.getText());  // speichert Eingabe in der Variable

            textfeld.setText(textfield.getText().concat("+")); // verknüpft Eingabe mit "+" ist aber auch Grund für das Problem

            operator ='+';                                       // setzt operator Variable auf '+'   
            textfeld.setText("");                                // leert das Textfeld nach Knopfdruck   
        }

Hallo,
ich bin gerade dabei die actionPerformed Methode für einen Button zu schreiben. Wie mit den Kommentaren schon angedeutet, soll bei Knopfdruck der Wert in num1 gespeichert werden. Das klappt auch. Die operator Variable speichert das Zeichen, hier "+" um es später mittels einem switch, der jeweiligen Operation zuzuordnen.
Das klappt auch.

Jetzt das Problem:
Eigentlich würde ich gern auf das leeren des Textfelds verzichten und stattdessen die Verknüpfung mit dem "+" Zeichen auf dem Textfeld haben und später leeren.
Aber wenn ich nicht leere dann kann ich die Eingabe nicht korrekt verarbeiten, weil dann ja nicht mehr der vorherige Wert gespeichert wird sondern, die gesamte Eingabe samt "+".

Ich hoffe ihr versteht was ich meine.

Weiß jemand wie ich das besser machen kann?

 

[mihe7]

Da gibt es diverse Möglichkeiten:

1. Das Textfeld wirklich nur zur Eingabe der Zahlen verwenden, die Rechnung in ein separates Feld ausgeben.
2. Im Textfeld die letzte Zahl suchen (z. B. den letzten Operator im Text suchen und dann die Zahl rechts davon verwenden)
3. Das Textfeld in einen Abstract Syntax Tree parsen (nicht ganz trivial, erlaubt dann die Eingabe von Rechnungen inkl. Berücksichtigung der Operatorreihenfolge)

 

[LouCyphre]

Zu 1.) Das versteh ich nicht ganz wie du das meinst. Die Rechnung passiert ja eigentlich nicht in dem Textfeld. Es zeigt ja nur die Eingaben an und soll die erste Eingabe vor dem operator, hier "+", speichern. oder wie meisnt du das?

zu 2.) Hat da JTextfield schon ne passende Methode zu?

 

[mihe7]

Wenn ich Dich richtig verstanden habe, dann hast Du ein Textfeld, in das der Benutzer eine Zahl eintippt, die Du in Zeile 8 parst. Sagen wir mal "100,5". Jetzt drücke ich plus und im Textfeld steht "100,5+". Dann tippe ich eine weitere Zahl ein, dann stünde im Textfeld z. B. "100,5+3". Jetzt funktioniert das Parsen der Zahl natürlich nicht mehr.

Daher in 1) die einfache Lösung mit einem separaten Feld. Ich tippe in das Textfeld 100,5 ein und drücke den "+"-Button, dann landet "100,5+" in einem separaten Feld zur Anzeige. Das Textfeld ist leer, dort tippe ich dann 3 ein und drücke z. B. den "=" Button. Dann wird die Anzeige aktualisiert zu "100,5 + 3 = 103,5" und das Textfeld ist wieder leer.

zu 2) Nein, das Textfeld selbst nicht. String hat Methoden wie z. B. indexOf oder split.

String eingabe = "100,5*2+1-5";
String[] einzelteile = eingabe.split("\\+|-|\\*|/");
System.out.println(Arrays.toString(einzelteile));
System.out.println(einzelteile[einzelteile.length-1]);

Liefert z. B.

[100,5, 2, 1, 5]
5

 

[LouCyphre]

Okay danke!

String[] einzelteile = eingabe.split("\\+|-|\\*|/");

Das ist nur ein dummy wert nehm ich an?

ich überlege 1) & 2) zu verknüpfen, so dass das "Zwischen"ergbnis noch zusätzlich angezeigt werden kann.
Dazu nochmal ne Frage : Weißt du wie die Textfelder überlappen lassen kann so das z.B das eine mit dem Ergebnis kleiner oben rechts in der Ecke des 1. Textfeldes liegt?

 

[mihe7]

Das ist nur ein dummy wert nehm ich an?

Nö, split() teilt einen String an den Stellen auf, an denen der übergebene reguläre Ausdruck matched. Der Ausdruck "\\+|-|\\*|/" bedeutet einfach, dass als "Trennzeichen" sowohl "+", "-", "/" als auch "*" verwendet werden.

Wenn Du z. B. nur das "+" berücksichtigen willst: eingabe.split("\\+")

Aus "7+5" wird ein Array mit zwei Elementen: 7 und 5. Durch den regulären Ausdruck spielt es keine Rolle ob Du an der Stelle des "+" eben evtl. ein "-", ein "/" oder ein "*" steht.

 

[LouCyphre]

if(event.getSource()==plusButton){
    textfeld.setText(textfeld.getText().concat("+"));
    String eingabe = textfeld.getText();
    String[] einzeteile = eingabe.split("\\+|-|\\*|/");
    num1 = Double.parseDouble(einzelteile[einzelteile.length-1]);
    operator = "+";
        }

macht das so Sinn?

 

[mihe7]

Nein. In Zeile 5 musst Du einzelteile[einzelteile.length-1] schreiben. Außerdem willst Du zum Rechnen ja eine Zahl und keinen String haben, daher müsstest Du noch nach double parsen. Sonderfälle solltest Du auch behandeln.

String zahl = einzelteile[einzelteile.length-1];
if (zahl.isEmpty()) {
    // Tu, was notwendig ist
} else {
    num1 = Double.parseDouble(zahl); // probiere, den Spaß in eine Zahl zu wandeln -> Fehlerbehandlung nicht vergessen.
}

 

[LouCyphre]

@mihe7 ja hab ich auch gemerkt und es nochmal korregiert, hast du wahrscheinlich nicht gesehen.

mein Code von oben funktioniert trotz parsen und nicht.
Aber das liegt wahrscheinlich an der weiteren Verarbeitung

 

[mihe7]

funktioniert trotz parsen und nicht.

"funktioniert nicht" ist jetzt keine Fehlerbeschreibung...

 

[LouCyphre]

Ja du hast recht, sry.

Es liegt daran, dass wenn ich dann den "=" Button drücke ist der Code gerade noch unbrauchbar.

if(event.getSource()==equButton) {
            
            num2=Double.parseDouble(textfield.getText());

            switch(operator) {

                case'+': result = num1 + num2; break;
                case'-': result = num1 - num2; break;
                case'*': result = num1 * num2; break;
                case'/': result = num1 / num2; break;
            }

Das Problem sollte das gleiche sein.
Hier müsste ich ebenfalls wieder splitten und dann nur den 1. Eintrag aus dem Array für num2 nutzen oder?

if(event.getSource()==equButton) {
            
            
            String eingabe = textfield.getText();
            String[] einzelteile = eingabe.split("\\+|-|\\*|/");
            num2=Double.parseDouble(einzelteile[einzelteile.length]);

            switch(operator) {

                case'+': result = num1 + num2; break;
                case'-': result = num1 - num2; break;
                case'*': result = num1 * num2; break;
                case'/': result = num1 / num2; break;
            }

 

[Jw456]

Hallo

Das schaut so aus als ob du einen Taschenrechner schreiben willst der die Operationen wie es viele Apps machen in der Anzeige mit anzeigt.


Ich würde das etwas trennen. Nicht erst die Anzeige zusammen bauen lassen und dann wider trennen um dann die Berechnung zumachen .
Ich würde das bei der Eingabe schon berechnen oder in einer Liste festhalten.
Eingabe und Anzeige etwas trennen .

 

[mihe7]

Das Problem sollte das gleiche sein.

Du solltest aber immer gleich das Zwischenergebnis berechnen.

 

[LouCyphre]

macht es ja in result oder?

[CODE lang="java" title="plus button"]if(event.getSource()==plusButton) {

textfield.setText(textfield.getText().concat("+"));
String eingabe = textfield.getText();
String[] einzelteile = eingabe.split("\\+|-|\\*|/");
num1 = Double.parseDouble(einzelteile[einzelteile.length-1]);
}[/CODE]

if(event.getSource()==equButton) {

            String eingabe = textfield.getText();
            String[] einzelteile = eingabe.split("\\+|-|\\*|/");

            num2=Double.parseDouble(einzelteile[einzelteile.length-2]);

            switch(operator) {

                case'+': result = num1 + num2; break;
                case'-': result = num1 - num2; break;
                case'*': result = num1 * num2; break;
                case'/': result = num1 / num2; break;
            }

Jetzt habe ich es so. An und für sich funktioniert es, allerdings gibt es mir als Ergebnis immer " 0.0 " aus.
Woran liegt das noch?

@Jw456
Ich weiß, dass design ist fragwürdig, aber als erster Entwurf 0.01 ist es erstmal okay

 

[Jw456]

Du solltest aber immer gleich das Zwischenergebnis berechnen.

aber auch Punkt vor Strich Rechnung beachten. Denn du zeigst es ja auch an.

zB 5+3*4-1 = 16

Wenn du sequenziell arbeitest was kommt raus ?

 

[kneitzel]

Nur ein kleiner Einwurf: Methoden sollten kurz und übersichtlich sein.

Daher machen so große Methoden, bei denen dann noch massiv unterschieden wird wie mit if(event.getSource()==equButton) { absolut keinen Sinn.

Denn um die Methoden klein zu halten, würde sich dieser ActionListener vereinfachen zu etwas wie:

if(event.getSource()==equButton) {
    doEqualsButtonAction();
}

Und dann braucht man diese Methode auch gar nicht mehr, denn der Action Listener wird dann direkt der Aufruf der Methode über Code a.la.
equButton.addActionListener(e -> doEqualsButtonAction());

Oder wenn man der Methode noch das Event mitgibt, dann reicht sogar ein:
equButton.addActionListener(this::doEqualsButtonAction);

doEqualsButtonAction dann ggf. noch in das umbenennen, was die Methode genau macht und schon hat man besser lesbaren Code.

Ja, Lambda Ausdrücke und Methoden Referenzen sind am Anfang ggf. etwas Komplexität, die man gerne weglassen möchte. Aber bei GUI Entwicklung mit Swing oder JavaFX ist dies wichtig, damit man eben lesbaren Code hat und behält.

 

[mihe7]

macht es ja in result oder?

Aber nicht an der richtigen Stelle.

Ich würde an Deiner Stelle erstmal folgendes überlegen:
1. Du hast ein Ergebnis, das zu Beginn erstmal 0 ist.
2. Du merkst Dir den Operator, der zu Beginn erstmal auf "+" steht.
3. Du hast eine Eingabe
4. Du hast Buttons für Operatoren

Wenn Du nun einen Operator-Button anklickst, nimmst Du die Zahl im Textfeld (ggf. nach split) und verknüpfst diese mit dem alten Operator und dem bisherigen Ergebnis zum neuen Ergebnis. Anschließend merkst Dir den Operator entsprechend des geklickten Buttons. Der gemerkte Operator wird erst beim nächsten Klick auf einen Operator-Button angewendet.

 

[LouCyphre]

Nur ein kleiner Einwurf: Methoden sollten kurz und übersichtlich sein.

Daher machen so große Methoden, bei denen dann noch massiv unterschieden wird wie mit if(event.getSource()==equButton) { absolut keinen Sinn.

Denn um die Methoden klein zu halten, würde sich dieser ActionListener vereinfachen zu etwas wie:

if(event.getSource()==equButton) {
    doEqualsButtonAction();
}

Und dann braucht man diese Methode auch gar nicht mehr, denn der Action Listener wird dann direkt der Aufruf der Methode über Code a.la.
equButton.addActionListener(e -> doEqualsButtonAction());

Oder wenn man der Methode noch das Event mitgibt, dann reicht sogar ein:
equButton.addActionListener(this::doEqualsButtonAction);

doEqualsButtonAction dann ggf. noch in das umbenennen, was die Methode genau macht und schon hat man besser lesbaren Code.

Danke für den Einwurf!
Ursprünglich hatte ich auch schon die Berechnungen auszulagern.

Aber ich hab es bisher so wie gezeigt gemacht, weil ich bisschen stutzig geworden bin, weil ich nach meiner Auffassung, dann für jeden Button der eine Operation (+ , - , /, * )inne hat eine Hilfsklasse schreiben müsste, die dann jeweils ActionListener implementiert. Oder?

Weil ja sonst

equButton.addActionListener(this::doEqualsButtonAction);

schon funktioniert,aber ich ja nur die actionPerformed Methode einmal schreiben kann.

///// zur Methode an sich:
Das Ergebnis, die beiden Zahlvariablen, sowie die operator Variable habe ich als Instanzvariable geschrieben.
@mihe7
Ich versuchs mal, ich muss aber erstmal überlegen wie ich das so umsetzen kann.

 

[mihe7]

Ich versuchs mal, ich muss aber erstmal überlegen wie ich das so umsetzen kann.

Ganz einfach, indem Du die Rechnung durchführst, bevor Du den geklickten Operator setzt. Dann wird der alte Operator verwendet. Die Berechnung in eine eigene Methode, dann müssen die Listener nur noch die Methode aufrufen.

 

[kneitzel]

schon funktioniert,aber ich ja nur die actionPerformed Methode einmal schreiben kann.

Also mein Einwurf war etwas zu früh - löse erst einmal das andere Problem und dann erläutere ich (oder jemand anderes) wie sowas noch umsetzbar wäre. Nur als kleine Info: Du wirst keinerlei actionPerformed Methode mehr haben und das (funktionale) Interface ActionListener nicht mehr direkt mit einer Klasse implementieren. Aber das behalten wir jetzt erst einmal im Hinterkopf und kommen später darauf zurück.

 

[LouCyphre]

int result = 0;                // beide als Instanzvariable?
String operator = "+";


public int addition(String operator, int result){
        
        textfeld.setText(textfield.getText().concat("+"));
        String eingabe = textfeld.getText();
        String[] einzeteile = eingabe.split("\\+|-|\\*|/");
        num1 = [einzelteile.length-1];  

        return result = result + num1;
        }

Aber nicht an der richtigen Stelle.

Ich würde an Deiner Stelle erstmal folgendes überlegen:
1. Du hast ein Ergebnis, das zu Beginn erstmal 0 ist.
2. Du merkst Dir den Operator, der zu Beginn erstmal auf "+" steht.
3. Du hast eine Eingabe
4. Du hast Buttons für Operatoren

Wenn Du nun einen Operator-Button anklickst, nimmst Du die Zahl im Textfeld (ggf. nach split) und verknüpfst diese mit dem alten Operator und dem bisherigen Ergebnis zum neuen Ergebnis. Anschließend merkst Dir den Operator entsprechend des geklickten Buttons. Der gemerkte Operator wird erst beim nächsten Klick auf einen Operator-Button angewendet.

Das wäre hier mein Versuch die Methode schreiben. Ich muss gestehen, dass deine Hinweise ersteinmal einleuchten klingen mich aber dann doch bisschen verwirren.

Also mein Einwurf war etwas zu früh - löse erst einmal das andere Problem und dann erläutere ich (oder jemand anderes) wie sowas noch umsetzbar wäre. Nur als kleine Info: Du wirst keinerlei actionPerformed Methode mehr haben und das (funktionale) Interface ActionListener nicht mehr direkt mit einer Klasse implementieren. Aber das behalten wir jetzt erst einmal im Hinterkopf und kommen später darauf zurück.

Klingt interessant. Ich bin gespannt was du zu erzählen hast.

 

[mihe7]

Ich muss gestehen, dass deine Hinweise ersteinmal einleuchten klingen mich aber dann doch bisschen verwirren.

Das Problem ist ja, dass die Berechnung erst durchgeführt werden kann, wenn beide Operanden und der Operator bekannt sind, der zweite Operand aber erst nach dem Operator eingegeben wird. Bei "100 +" kannst Du die Addition ja noch nicht durchführen, sondern musst die Eingabe des zweiten Operanden abwarten.

Stellen wir uns vor, Du hättest als Ergebnis einer bereits vorangegangenen Rechnung 100 erhalten. Jetzt willst Du davon 25 abziehen, d. h. Du drückst "-". Das "-" merkt sich das Programm, da der zweite Operand noch fehlt. Anschließend tippst Du 25 ein. Die Eingabe der Zahl musst Du irgendwie abschließen, z. B. indem Du einen Button betätigst, sagen wir mal "=". Beim Klick auf das "=" wird das bisherige Ergebnis (100) mit dem gemerkten Operator ("-") und der eingegebenen Zahl (25) verknüpft, um das neue Ergebnis zu erhalten (100 - 25 = 75).

Das muss natürlich genauso funktionieren, wenn Du statt dem "=" einen Operator-Button klickst, weil Du weiterrechnen willst.

Nochmal von vorne: Du hast als Ergebnis einer bereits vorangegangenen Rechnung 100 erhalten. Jetzt willst Du davon 25 abziehen, d. h. Du drückst "-". Das "-" merkt sich das Programm. Anschließend tippst Du 25 ein. Die Eingabe musst Du irgendwie abschließen, z. B. indem Du einen Button betätigst, sagen wir mal "*". Beim Klick auf das "*" wird also das bisherige Ergebnis (100) mit dem gemerkten Operator ("-") und der eingegebenen Zahl (25) verknüpft, um das neue Ergebnis zu erhalten (100 - 25 = 75). Außerdem merkst Du Dir als Operator den "*". Dann tippst Du z. B. eine 2 ein und klickst auf "=". Jetzt wird das bisherige Ergebnis (75) mit dem gemerkten Operator ("*") und der eingegebenen Zahl (2) verknüpft, um das neue Ergebnis zu erhalten (75 * 2 = 150).

Soweit, so klar.

Jetzt haben wir nur noch ein kleines Problem: wenn Du eine ganz neue Rechnung beginnst, dann hast Du als Ergebnis normalerweise eine 0 stehen und kein Mensch geht her und drückt erstmal auf "+", um anschließend eine Zahl einzugeben. Daher stellen wir einfach den Zustand im Programm her, als ob genau das bereits eingegeben worden wäre. Wir stellen am Anfang also das Ergebnis auf 0 und merken uns den Operator "+".

Wenn man jetzt eine Zahl (100) eintippt und anschließend auf "-" drückt, wird das bisherige Ergebnis (0) mit dem gemerkten Operator ("+") und der eingegebenen Zahl (100) verknüpft, um das neue Ergebnis (100) zu erhalten. Außerdem merkst Du Dir anschließend den eingegebenen Operator ("-").

Mit diesem kleinen Trick (so tun, als ob die Rechnung "0 +" bereits eingegeben worden wäre) funktioniert die Rechnerei ganz unabhängig davon, ob die Rechnung neu begonnen hat oder nicht, immer auf die gleiche Weise und wir brauchen keine ggf. komplizierten Sonderbehandlungen.

 

[Jw456]

Nochmal von vorne: Du hast als Ergebnis einer bereits vorangegangenen Rechnung 100 erhalten. Jetzt willst Du davon 25 abziehen, d. h. Du drückst "-". Das "-" merkt sich das Programm. Anschließend tippst Du 25 ein. Die Eingabe musst Du irgendwie abschließen, z. B. indem Du einen Button betätigst, sagen wir mal "*". Beim Klick auf das "*" wird also das bisherige Ergebnis (100) mit dem gemerkten Operator ("-") und der eingegebenen Zahl (25) verknüpft, um das neue Ergebnis zu erhalten (100 - 25 = 75). Außerdem merkst Du Dir als Operator den "*". Dann tippst Du z. B. eine 2 ein und klickst auf "=". Jetzt wird das bisherige Ergebnis (75) mit dem gemerkten Operator ("*") und der eingegebenen Zahl (2) verknüpft, um das neue Ergebnis zu erhalten (75 * 2 = 150).

Soweit, so klar.

punkt vor strich rechnung wurde hier aber nicht beachtet.

100-25*2 = 50

(100-25)*2 = 150

 

[mihe7]

punkt vor strich rechnung wurde hier aber nicht beachtet.

Richtig, das wird sie aber bei den einfachen Taschenrechnern (und den alten Rechenmaschinen) auch nicht und ich halte das für den TE auch für zu kompliziert:

3. Das Textfeld in einen Abstract Syntax Tree parsen (nicht ganz trivial, erlaubt dann die Eingabe von Rechnungen inkl. Berücksichtigung der Operatorreihenfolge)

Klar, man kann sich auch ein Stück Code (Shunting Yard) kopieren und dann das Textfeld auswerten, aber ich denke mal nicht, dass das im Sinne der Aufgabe ist

 

[LouCyphre]

Mit diesem kleinen Trick (so tun, als ob die Rechnung "0 +" bereits eingegeben worden wäre) funktioniert die Rechnerei ganz unabhängig davon, ob die Rechnung neu begonnen hat oder nicht, immer auf die gleiche Weise und wir brauchen keine ggf. komplizierten Sonderbehandlungen.

if(event.getSource()==plusButton) {

            textfield.setText(textfield.getText().concat("+"));
            String eingabe = textfield.getText();
            String[] einzelteile = eingabe.split("\\+|-|\\*|/");
            num1 = Double.parseDouble(einzelteile[einzelteile.length-1]);
        }

Hier fragt es ja die erste Zahl ab.

Dann drücke ich den "=" Operator.

if(event.getSource()==equButton) {

            String eingabe = textfield.getText();
            String[] einzelteile = eingabe.split("\\+|-|\\*|/");

            num2=Double.parseDouble(einzelteile[einzelteile.length-2]);

            switch(operator) {

                case'+': result = num1 + num2; break;
                case'-': result = num1 - num2; break;
                case'*': result = num1 * num2; break;    
                case'/': if (number2 == 0)
                                 return 0;
                             result = num1 / num2; break;
            }
        textfield.setText(String.valueOf(result));

            num1=result;
  }

gebe das Ergebnis auf dem Textfeld aus und speichere das Ergebnis in num1 (zwischen) und kann dann ja damit weiter rechnen.

oder nicht ?

ich weiß, es hat schon eine gweisse Tragik-Komik inne und ich muss auch manchmal lachen, weil ich es irgendwie nicht checke, aber kannst du mir vielleicht am Code sagen wo was fehlt, was genau falsch ist oder auch ob alles kompletter Quatsch ist?

Danke!

 

[Jw456]

if(event.getSource()==plusButton) {

            textfield.setText(textfield.getText().concat("+"));
            String eingabe = textfield.getText();
            String[] einzelteile = eingabe.split("\\+|-|\\*|/");
            num1 = Double.parseDouble(einzelteile[einzelteile.length-1]);
        }

Hier fragt es ja die erste Zahl ab.

nein da bist du schon bein plus Operator. die zahl war vorher.

 

[mihe7]

weil ich es irgendwie nicht checke, aber kannst du mir vielleicht am Code sagen wo was fehlt, was genau falsch ist oder auch ob alles kompletter Quatsch ist?

Der Code ist das geringste Problem, der ist in erster Linie nur falsch zusammengesetzt. Viel wichtiger wäre das Aha-Erlebnis.

Hier fragt es ja die erste Zahl ab.

Hier wird die letzte eingegebene Zahl (vor dem Operator) abgefragt. Bei "100", "+"-Button, wäre num1 = 100.

Was passiert, wenn Du anschließend nochmal "100", "+"-Button wiederholst? Dann steht zwar in der Eingabezeile "100+100+", num1 ist aber wieder 100. Passt jetzt nicht so wirklich, oder?

 

[Jw456]

Ich würde mir nicht deine Zahlen aus dem zusammengebauten String holen sondern.

Sondern bei der Eingabe der Zahlen in die erste Variable (num1) speichern.

Wird dann der plus Button gedrückt merkst du dir das in einer Operator variablen.

Wird jetzt eine zweite Zahl eingegeben speicherst du die Zahl in der zweiten Variablen (num2) jetzt kannst du die Berechnung starten. Das Ergebnis dann in die erste Variable speichern (num1).

Folgt jetzt ein weiterer Operator speichert du ihn wider und die folgende zahl in der zweiten Variablen (num2) dann wider berechnen.



Wird „=“ gedrückt kannst du das Ergebnis (num1) ausgeben

 

[LouCyphre]

Hier wird die letzte eingegebene Zahl (vor dem Operator) abgefragt. Bei "100", "+"-Button, wäre num1 = 100.

genau.

if(event.getSource()==plusButton) {

            textfield.setText(textfield.getText().concat("+")); // setzte das "+" -> 3+
            String eingabe = textfield.getText();               // 3+ in String schreiben
            String[] einzelteile = eingabe.split("\\+|-|\\*|/");// Zahl vom Operator trennen
            num1 = Double.parseDouble(einzelteile[einzelteile.length-1]);// num1 = 3
        }

Was passiert, wenn Du anschließend nochmal "100", "+"-Button wiederholst? Dann steht zwar in der Eingabezeile "100+100+", num1 ist aber wieder 100. Passt jetzt nicht so wirklich, oder?

Das passt nicht so wirklich. das stimmt. Der Aha effekt wäre jetzt nach 100+100 ein Zwischenergebnis zu speichern. Also dann Result ist num1 + num2 und danach num1 = result, ja?

 

[mihe7]

jetzt nach 100+100 ein Zwischenergebnis zu speichern.

Ja, wobei Ergebnis und Zwischenergebnis dasselbe meint.

Du machst es Dir zu schwer. Du hast einfach ein Ergebnis, einen Operator und einen Operanden. Den Operator wendest Du einfach immer auf das Ergebnis und den eingegebenen Operanden an und erhältst so das neue Ergebnis, z. B.

ergebnis := addiere(ergebnis, operand);
ergebnis := multipliziere(ergebnis, operand);
usw.

Aus dem Textfeld erhältst Du immer nur den Operanden.

 

[LouCyphre]

Ich würde mir nicht deine Zahlen aus dem zusammengebauten String holen sondern.

Sondern bei der Eingabe der Zahlen in die erste Variable (num1) speichern.

Wird dann der plus Button gedrückt merkst du dir das in einer Operator variablen.

Wird jetzt eine zweite Zahl eingegeben speicherst du die Zahl in der zweiten Variablen (num2) jetzt kannst du die Berechnung starten. Das Ergebnis dann in die erste Variable speichern (num1).

Folgt jetzt ein weiterer Operator speichert du ihn wider und die folgende zahl in der zweiten Variablen (num2) dann wider berechnen.



Wird „=“ gedrückt kannst du das Ergebnis (num1) ausgeben

Okay absolut plausibel!

Eingabe über Button : 100
    num1 = 100;

Eingabe über Button : +
    operator = "+";

Eingabe über Button : 10
    num2 = 10;

Rechnung : num1 + num2 = result;
         num1 = result;

if("= Button"){
    
    print(num1);
}

so der Pseudocode, ja?

Aber wo liegt der qualitative Unterschied zur im letzten Post beschrieben Vorgehensweise?

 

[mihe7]

Hier mal quick & dirty für die Befehlszeile:

import java.util.Scanner;

public class Test {
    private Scanner sc = new Scanner(System.in);
    private double ergebnis = 0;
    private char operator = '+';

    public void run() {
        do {
            double operand = liesZahl("Zahl: ");
            berechne(operand);        
            operator = liesZeichen("Operator (\"=\" zur Ausgabe): ");
        } while (operator != '=');

        System.out.println("Ergebnis: " + ergebnis);
    }

    private void berechne(double operand) {
        switch (operator) {
            case '+': ergebnis += operand; break;
            case '-': ergebnis -= operand; break;
            case '*': ergebnis *= operand; break;
            case '/': ergebnis /= operand; break;
        }
    }

    private double liesZahl(String prompt) {
        while (true) {
            System.out.print(prompt);
            String line = sc.nextLine();
            try {
                return Double.parseDouble(line);
            } catch (NumberFormatException ex) {
                System.out.println("Bitte eine valide Zahl eingeben!");
            }
        } 
    }

    private char liesZeichen(String prompt) {
        String line;
        do {
            System.out.print(prompt);
            line = sc.nextLine();
        } while (line.trim().isEmpty());

        return line.trim().charAt(0);
    }
        
    public static void main(String[] args) {
        new Test().run();
    }
}

 

[LouCyphre]

@mihe7 tausend Dank! Auch dafür, dass du nach dem 10. Post nicht gesagt hast : "Lass gut sein, der will mich doch verarschen "

Ich versuch das jetzt mal auf die GUI anzuwenden oder macht das mehr Sinn vorher über den Lösungsvorschlag von @kneitzel nachzudenken?

 

[mihe7]

Wichtig ist, dass Du das Prinzip verstehst/verstanden hast. Der Code ist nur dazu da, dieses mal live zu zeigen. Damit kannst Du das etwas besser nachvollziehen. Wenn Du was nicht verstanden hast, kannst Du z. B. einfach mal Zwischenergebnisse ausgeben.

Auch dafür, dass du nach dem 10. Post nicht gesagt hast : "Lass gut sein, der will mich doch verarschen "

Nein, das ist hier Sinn und Zweck der Sache, beim Verständnis zu helfen. Die Threads sind dann natürlich entsprechend länger. Natürlich hätte ich gleich einfach eine fertige Lösung hinklatschen können, dann ist der Lerneffekt aber gleich 0.

BTW: Der längste Thread (da haben natürlich auch andere mitgeschrieben) hatte 500 Kommentare (wobei wir die 500 absichtlich voll gemacht haben). Das war aber die absolute Ausnahme und schon mehr zur allgemeinen Belustigung, weil der Typ so hartnäckig war, obwohl er wriklich gar nichts verstanden hat. Dagegen sind 100 und mehr durchaus schon mal drin

Was @kneitzel betrifft: ich weiß jetzt nicht, welchen Vorschlag Du meinst. Ich wüde sagen: schreib erstmal Deinen Code, so dass er funktioniert. Wenn Du willst, kannst Du ihn (oder Teile davon) ja posten, dann kann man die Vorschläge immer noch umsetzen.

 

[LouCyphre]

Ich wüde sagen: schreib erstmal Deinen Code, so dass er funktioniert. Wenn Du willst, kannst Du ihn (oder Teile davon) ja posten, dann kann man die Vorschläge immer noch umsetzen.

Das mach ich!

BTW: Der längste Thread (da haben natürlich auch andere mitgeschrieben) hatte 500 Kommentare (wobei wir die 500 absichtlich voll gemacht haben). Das war aber die absolute Ausnahme und schon mehr zur allgemeinen Belustigung, weil der Typ so hartnäckig war, obwohl er wriklich gar nichts verstanden hat. Dagegen sind 100 und mehr durchaus schon mal drin

Da sind wir mit jetzt 35 ja noch gut im Rennen

 

[mihe7]

Da sind wir mit jetzt 35 ja noch gut im Rennen

Ja, das ist ja fast ein One-Liner

 

[Hildi0]

Hier ist mal ein ganz einfacher Parser nach Dijkstra, der von links nach rechts rechnet und Klammern (noch) nicht berücksichtigt:

import java.util.ArrayDeque;
import java.util.Deque;

public class Parser1 {
    public static double parse(String term) {
        String operators = "+-*/";
        String digits = ".0123456789";
        Deque<String> queue1 = new ArrayDeque<>();
        Deque<String> queue2 = new ArrayDeque<>();
        StringBuilder number = new StringBuilder();
        for (char c : term.toCharArray()) {
            String s = String.valueOf(c);
            if (digits.contains(s)) {
                number.append(s);
            } else {
                if (operators.contains(s)) {
                    queue1.add(s);
                }
                if (number.length() > 0) {
                    queue2.add(number.toString());
                    number = new StringBuilder();
                }
            }
        }
        if (number.length() > 0) {
            queue2.add(number.toString());
        }
        double result = Double.parseDouble(queue2.pop());
        while (!queue1.isEmpty()) {
            char op = queue1.pop().charAt(0);
            double val = Double.parseDouble(queue2.pop());
            switch (op) {
                case '+' -> result += val;
                case '-' -> result -= val;
                case '*' -> result *= val;
                case '/' -> result /= val;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        System.out.println(parse("1.23 + 2.45-1.23 /2* 4")); // e.g. ~4.9
    }
}

 

[LouCyphre]

Also hier mal ein Gedanke:

private double ergebnis = 0;                         // als Instanzvariablen
private char operator = '+';                                                
private JButton[] numberButtons = new JButton[10];      

//....

    private void berechne(double operand) {                    // diese Methode würde ich so beibehalten
        switch (operator) {
            case '+': ergebnis += operand; break;
            case '-': ergebnis -= operand; break;
            case '*': ergebnis *= operand; break;
            case '/': ergebnis /= operand; break;
        }
    }

[CODE lang="java" title="actionPerformed"]@Override

public void actionPerformed(ActionEvent event) { // bisher : überträgt Zahl von Button ins Textfeld

for(int i=0;i<10;i++) {

if(event.getSource() == numberButtons) {

textfield.setText(textfield.getText().concat(String.valueOf(i)));
}
}

if(event.getSource()==plusButton) {

operator ='+';
}[/CODE]


Was ich mich jetzt nur Frage wie ich jetzt die Operanden und Operatoren am besten auslese?
Ich würde dies am liebsten als Methode beibehalten, allerdings setzte ich alles ja über Buttons weswegen mir gerade nur in den Sinn kommt alle
numberButton über if(e.getSource()==...) abzufragen. Aber das erscheint mir zu verkompliziert zu sein.

Zusätzlich würde ich die Logik gern von der Klasse trennen, die gegenwärtig das JFrame + Buttons stämmt trennen, da wäre ja Das ganze Zeugs, also auslesen und rechnen zusammen zuführen besser dran oder?

 

[mihe7]

Was ich mich jetzt nur Frage wie ich jetzt die Operanden und Operatoren am besten auslese?

Was meinst Du? Wenn Du Buttons hast, weißt Du ja, was gedrückt wurde, da musst Du ja nix auslesen.

allerdings setzte ich alles ja über Buttons weswegen mir gerade nur in den Sinn kommt alle
numberButton über if(e.getSource()==...) abzufragen. Aber das erscheint mir zu verkompliziert zu sein.

Da gibt es diverse Möglichkeiten, z. B. könntest Du einen Listener schreiben, der die Beschriftung des angeklickten Buttons verwendet.

private ActionListener numberButtonListener = new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent event) {
        JButton button = (JButton) event.getSource();
        String input = button.getText();
        textfield.setText(textfield.getText().concat(input));
    }
};

Zusätzlich würde ich die Logik gern von der Klasse trennen, die gegenwärtig das JFrame + Buttons stämmt trennen, da wäre ja Das ganze Zeugs, also auslesen und rechnen zusammen zuführen besser dran oder?

Du kannst eine Calculator-Klasse schreiben, die Ergebnis und Operator verwaltet und die berechnen()-Methode enthält. Das wäre die Logik. Ein-/Ausgabe gehört dagegen zum UI, wobei das natürlich auch mehrere Klassen umfassen darf. Für die Listener bieten sich allerdings Lambda-Ausdrücke bzw. Methodenreferenzen an, wie es @kneitzel bereits gezeigt hat, statt ganze Klassen zu schreiben.

 

[kneitzel]

Zusätzlich würde ich die Logik gern von der Klasse trennen, die gegenwärtig das JFrame + Buttons stämmt trennen, da wäre ja Das ganze Zeugs, also auslesen und rechnen zusammen zuführen besser dran oder?

Hier würde ich vorschlagen, dass Du einmal deinen Code komplett zeigst. Dann würde ich da ein paar kleine Veränderungen vornehmen und Dir zeigen, was ich bereits angedeutet habe (mit ein paar Erläuterungen oder Links zu Dokumentation).

In dem Zusammenhang kann ich dann auch gerne das Thema "Funktionlitäten trennen" anreißen. Dabei aber schon jetzt der Hinweis, dass ich da nicht zu tiefe Erläuterungen bringen und zumindest versuchen werde, mich da zurück zu halten und nur Schlagwörter für Suchen zu bringen.

 

[LouCyphre]

Da gibt es diverse Möglichkeiten, z. B. könntest Du einen Listener schreiben, der die Beschriftung des angeklickten Buttons verwendet.

Okay.

Dazu vllt kurz meinen Code

//numberButtons

JButton[] numberButtons = new JButton[10];
        for(int i = 0; i<10; i++) {

            numberButtons[i] = new JButton(String.valueOf(i));
            numberButtons[i].setFont(myFont);
            numberButtons[i].setFocusable(false);
        }

Die kann ich quasi nur mit Index aufrufen.

[CODE lang="java" title="von mihe7"]

private ActionListener numberButtonListener = new ActionListener() {
@Override
public void actionPerformed(ActionEvent event) {
JButton button = (JButton) event.getSource(); // was macht (JButton) ?
String input = button.getText();
textfield.setText(textfield.getText().concat(input));
}
};

[/CODE]


Die Buttons für die Operationen sind in einer ArrayList und werden dann mit einer for each Schleife bestückt.

ArrayList<JButton> functionButtons = new ArrayList<>();

functionButtons.add(plusButton);
functionButtons.add(minusButton);
...
   
for(JButton fb : functionButtons) {

            fb.setFont(font);
            fb.setFocusable(false);
            fb. ...
        }

Also die beiden Codestellen sind für das schreiben der Zeichen in den Button und haben mit den ActionListener erstmal noch nix zutun.

Um jetzt so eine Form zu bekommen :
equButton.addActionListener(this::doEqualsButtonAction);

brauch ich eine doEqualsButtonAction Methode die das letzte (Zwischenergebnis) in das Textfeld schreibt.
Und wo bekomme ich dann das ActionListener Objekt her? Sollen dann die Buttons von Actionlistner erben damit ich die addActionListener aufrufen kann?

In dem Zusammenhang kann ich dann auch gerne das Thema "Funktionlitäten trennen" anreißen. Dabei aber schon jetzt der Hinweis, dass ich da nicht zu tiefe Erläuterungen bringen und zumindest versuchen werde, mich da zurück zu halten und nur Schlagwörter für Suchen zu bringen.

Ich komm dann nochmal auf dich zurück. Ich hab das zwar alles irgendwie schonmal in der Uni gehört, aber da wurde das oft nur theoretisch und zu wenig an praktischen Beispielen angesprochen.

 

[kneitzel]

Und wo bekomme ich dann das ActionListener Objekt her? Sollen dann die Buttons von Actionlistner erben damit ich die addActionListener aufrufen kann?

Das Thema, das Dir jetzt wohl noch fehlt, heisst: "functional Interface".

Siehe z.B. https://www.baeldung.com/java-8-functional-interfaces

Interfaces, bei denen nur eine Methode zu implementieren ist, haben diese spezielle Bezeichnung. Ganz einfach ausgedrückt: Es wird also nur eine Methode benötigt und diese kann man daher einfach per Lambda Ausdruck oder per Methodenreferenz beisteuern.

==> Es gibt einfach keine ActionListener Objekte mehr und diese brauchst Du auch nicht mehr.

Die Umsetzung ist daher ganz einfach: die actionPerformed Methode kann jetzt einen beliebigen Namen bekommen. (Damit kann der auch endlich etwas sinnvolles aussagen!)

Nehmen wir Deinen Code:

private ActionListener numberButtonListener = new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent event) {
        JButton button = (JButton) event.getSource(); // was macht (JButton) ?
        String input = button.getText();
        textfield.setText(textfield.getText().concat(input));
    }
};

Was macht denn die Methode actionPerformed? Der Name sagt ja nichts dazu aus, was die Methode macht sondern sagt maximal aus, wann dieser aufgerufen wird (Durch eine Action - ist halt ein ActionListener). Und Du hast sehr viele Codezeilen ... eine anonyme, innere Klasse, .....

private void appendNumberButtonTextAction(ActionEvent event) {
    if (event.getSource() instanceof JButton button) {
        String input = button.getText();
        textfield.setText(textfield.getText().concat(input));
    }
}

==> Was macht das (JButton)? Das nennt sich "cast". getSource() gibt eben kein JButton sondern ein Object zurück. Damit Du auf die Methoden von JButton zugreifen kannst, musst Du einen cast machen. So source aber eben kein JButton wäre (Du hast es versehentlich einem anderen Control zugewiesen oder so), dann bekommst Du eine ClassCastException.
Daher das schönere Konstrukt: Vor einem Cast prüft man, ob der cast möglich ist (instanceof Operator). Und mit aktuellem Java 16 kann man das "Pattern Matching for instanceof" nutzen, d.h. man packt die Variablendeklaration direkt mit in das instanceof. (jep 305/375 wäre Preview in Java 14/15, JEP 394 ist die finale Version in Java 16)

Und ohne pattern matching for instanceof wäre es der Code:

private void appendNumberButtonTextAction(ActionEvent event) {
    if (event.getSource() instanceof JButton) {
        JButton button = (JButton) event.getSource();
        String input = button.getText();
        textfield.setText(textfield.getText().concat(input));
    }
}

 

[LouCyphre]

Das klingt krass!

[CODE lang="java" title="von kneitzel"]private void appendNumberButtonTextAction(ActionEvent event) {
if (event.getSource() instanceof JButton button) {
String input = button.getText();
textfield.setText(textfield.getText().concat(input));
}
}

[/CODE]

Die Methode wäre dann universell anwendbar für Alle Number und FunctionButtos über

equButton.addActionListener(this::doEqualsButtonAction);

z.B. numberbutton.appendNumberButtonTextAction(this::doWasAuchImmer); ??

 

[kneitzel]

ja genau, so kann man das dann bauen. Wobei Buttons das unterschiedliche Methoden haben können. Aber es gibt in der Methode dann keine Prüfung mehr, welcher Button es war. So unterschiedliche Funktionalität gebraucht würde, würde man auch unterschiedliche Methoden haben.

 

[LouCyphre]

Das klingt doch erstmal gut.

Für die numberbuttons brauch ich ja theoretisch nur eine Methode, die aus dem Array die Zahl über den Index ausliest und ins Textfeld schreibt und eventuell in result speichert ( hab ich gerade noch nicht ausreichend drüber nachgedacht).

Und die Methode(n) für den Operator macht letztlich eine ähnliche Aufgabe. Nämlich den Operator merken und in mit der bisherigen Eingabe im Textfeld verknüpfen. Hierber ist nur die Frage ob ich das für jeden der 4-5 Operatoren in eine eigene Methode schreibe oder ob es machbar ist zumindest die Operatoren (+,-,*,/) zu vereinen.

 

[LouCyphre]

Nochmal kurz ein Teil off topic:

Ich benutze IntelliJ und jetzt zeigt es mir als Fehler an, dass das instanceof Pattern in Java 8 nicht unterstützt wird.

@kneitzel du hattest das ja vorhin schon angemerkt, dass das ein feature von Java 16 ist. Weißt du wie ich IntelliJ dazu bringe Java 16 zu nutzen?

EDIT:

Ich habs vorerst mal mit

private void appendNumberButtonTextAction(ActionEvent event) {
    if (event.getSource() instanceof JButton) {
        JButton button = (JButton) event.getSource();
        String input = button.getText();
        textfield.setText(textfield.getText().concat(input));
    }
}

gemacht

 

[kneitzel]

Evtl. nimmst Du da einfach statt einer Methoden-Referenz ein Lambda Ausdruck. Dann kann die Methode auch beliebige Parameter bekommen.

addButton.addActionListener(e -> operationButtonAction(e, "+"));

Die Methode hat dann noch einen weiteren Parameter. Aber wir haben jetzt schon wieder ein Konstrukt, das wir ja nicht wollten: Du hast ein Switch auf ein Argument um dann unterschiedliche Dinge zu machen. Sowas hatten wir ja in mehrere Methoden unterteilt. Aber der Unterschied ist ja nur, dass da eine unterschiedliche Operation ausgeführt wird, die zwei double entgegen nimmt und ein double zurück gibt. Das könnte man auch wieder in ein functional Interface packen oder man nutzt etwas, das es schon gibt: BiFunction.

Das wäre dann evtl. sowas:

addButton.addActionListener(e -> operationButtonAction(e, this::addOperation));

// ...

private void operationButtonAction(ActionEvent e, BiFunction<Double,Double,Double> f) {
    // ... Ergebnis wird mit f.apply(errsterDoube, zweiterDouble) berechnet.
}

private Double addOperation(Double value1, Double value2) {
    return value1 + value2;
}

Generell hast Du aber eine Reihe von Operatoren, die Du unterstützt. Und sowas ruft dann schon direkt nach Enum. Hier der Hinweis: Enum ist eine spezielle Klasse - kann also viele Dinge haben, die eine Klasse auch haben kann ...

Also bauen wir einmal ein Enum:

public enum SupportedOperation {
    ADDITION("+", (v1, v2) -> v1+v2),
    MULTIPLICATION("*", (v1, v2) -> v1*v2);
    
    private final String symbol;
    private final BiFunction<Double,Double,Double> func;
    
    SupportedOperations(final String symbol, final BiFunction<Double,Double,Double> func) {
        this.symbol = symbol;
        this.funv = func;
    }
    
    public String getSymbol() { return symbol; }
    
    public double calculate(double val1, double val2) { return func.apply(val1, val2); }
}

Und das lässt sich dann natürlich nutzen, indem man als Parameter des actionListeners eben ein SupportedOperation übergibt.
Auch bei der Erstellung der Buttons kann man das schon nutzen - dazu dient das getSymbol(). Das hätte man aber dann auch weglassen können..


Noch zur Erläuterung: das (v1, v2) -> v1+v2 ist ein Lambda Ausdruck. So muss man nicht lauter Methoden schreiben.

 

[kneitzel]

Weißt du wie ich IntelliJ dazu bringe Java 16 zu nutzen?

Ja







Ok, ich will ja nicht so sein. Öffne die Modul Settings von Deinem Modul in Intellij (Rechtclick: Open Modul Settings .... oder eben F4).

a) Unter SDKs kannst Du sicher stellen, dass ein JDK 16 vorhanden ist. Zur not kannst Du da auch ein JDK herunter laden lassen ("+" und dann Download JDK).
b)Unter Project dann das Project SDK Einstellen. Ebenso das Project Language Level.
c) Unter Moduls alle Module durchgehen und da das Language Level setzen.

 

[LouCyphre]

Ok, ich will ja nicht so sein.

Danke

 

[LouCyphre]

zu#47 das schau ich mir später nochmal genau an.

Ich verfolge gerade noch den anderen Ansatz.

addButton.addActionListener(this::doAddButtonAction);

// [...]

public void doAddButtonAction(ActionEvent e){

        display.setText(display.getText().concat("+"));
        operator = '+' ;
    }

funktioniert.

private JButton[] numberButtons;

/// [...]

numberButtons.addActionListener(this::appendNumberButtonTextAction); *

///[...]

public void appendNumberButtonTextAction(ActionEvent event) {
        for(int i=0;i<10;i++) {

            if(event.getSource() == numberButtons[i]) {

                display.setText(display.getText().concat(String.valueOf(i)));
            }
        }
    }

*funktioniert hingegen nicht, weil, so der Compiler , addActionListener nicht in JButton aufflösen kann.

aber addButton ist doch auch in JButton warum funktioniert es da, aber hier nicht?