GUI - JButton ohne Funktion?

Wuast

Bekanntes Mitglied
Hallo,
um die Erstellung eines GUI zu verstehen habe ich einen Taschenrechner nachgebaut (anhand eines YT Videos). Ich möchte es etwas verändern/erweitern, nämlich so, dass ich für die einzelnen Rechenaufgaben einen Button implementiere, der dann bei Klick auf " = " (ebenfalls ein JButton) die entsprechende Berechnung veranlasst. Ich habe mir dazu überlegt, dass ich mittels eines booleans die Aktion auslösen lassen könnte. S. hier:

Java:
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.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JTextField;


public class GuiTaschenrechner extends JFrame {  

   
    private JLabel labelForNumber1;
    private JLabel labelForNumber2;
   
    private JTextField fieldForNumber1;
    private JTextField fieldForNumber2;
   
    private JButton add;    boolean plus;
    private JButton sub;    boolean minus;
    private JButton mult;    boolean mal;
    private JButton div;    boolean geteilt;
   
    private JButton rechnungAusfuehren;
   
    public GuiTaschenrechner () {
       
        setTitle(Taschenrechner);
       
        setDefaultCloseOperation(EXIT_ON_CLOSE);    //Legt fest, was bei [X] passiert //Exit_On_CLOSE = Standard-Variable
       
        setLayout(new FlowLayout());    //Layout auswählen
        setSize(750, 150);                //Pixelgröße des Fensters
        setResizable(true);             //Fenstergröße (nicht) veränderbar
       
        initiateComponents();            //Methodenaufruf zur Initiation der Komponenten
       
        add(labelForNumber1);
        add(labelForNumber2);
        add(fieldForNumber1);
        add(add);                        //Button plus  
        add(sub);                        //Button minus
        add(mult);                        //Button mal
        add(div);                        //Button geteilt
        add(labelForNumber2);
        add(fieldForNumber2);
        add(rechnungAusfuehren);
       
        setLocationRelativeTo(null);    //Fenster in Mitte d. Bildschirms //null = Platzhalter
        setVisible(true);                //Sichtbarkeit Fenster  
    }
   
   
    private void initiateComponents() {  
       
        labelForNumber1 = new JLabel("Zahl 1: ");
       
        //HIER KOMMEN DIE JBUTTONS OHNE FUNKTION
        add = new JButton("+");
        add.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                plus = true;
            }
           
        });
       
        sub = new JButton("-");
        sub.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                minus = true;
            }
           
        });
       
        mult = new JButton("*");
        mult.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                mal = true;          
            }
           
        });
       
        div = new JButton("/");
        div.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
            geteilt = true;
            }
           
        });
       
        labelForNumber2 = new JLabel("Zahl 2: ");

        fieldForNumber1 = new JTextField(5);    //Feldbreite in Zeichen
        fieldForNumber2 = new JTextField(5);  
       
        rechnungAusfuehren = new JButton("= ");
        rechnungAusfuehren.addActionListener(new ActionListener() {    //anonyme innere Klasse

            @Override
            public void actionPerformed(ActionEvent e) {

                double zahl1 = Double.parseDouble(fieldForNumber1.getText());
                double zahl2 = Double.parseDouble(fieldForNumber2.getText());
               
                double ergebnis = 0;
               
                //warum wird dadurch die Rechnung nicht ausgelöst?
                if (plus = true) {
                    ergebnis = zahl1 + zahl2;
                }
                if (minus = true) {
                    ergebnis = zahl1 - zahl2;
                }
                if (mal = true) {
                    ergebnis = zahl1 * zahl2;
                }
                if (geteilt = true) {
                    ergebnis = zahl1 / zahl2;
                }
                else {
                    System.out.println("Falsche Eingabe.");
                }
                JOptionPane.showMessageDialog(GuiTaschenrechner.this, zahl1 + " " + " "      //hier fehlt noch etwas um das Label für den Operanden einzufügen
                + zahl2 + " = " + ergebnis, "Ergebnis:", JOptionPane.INFORMATION_MESSAGE);      
            }
        } );  

   
    }
   
}

Aufruf dann wie gewohnt in der Main. Leider scheint das nicht zu funktionieren. Es wird zwar alles dargestellt wie es soll, aber die JButton "+", "-", "*" & "/" sind entweder ohne Funktion ODER der Code funktioniert so noch nicht, weil die Berechnung nicht ausgeführt wird.

Ich verstehe aber nicht, wo das Problem liegt. Kann mir jemand weiterhelfen?

LG :)
 

Wuast

Bekanntes Mitglied
sollte doch bestimmt
Java:
if (plus == true) {
heißen.

und dann könntest du noch besser
Java:
if (plus == true) {
    ergebnis = zahl1 + zahl2;
    plus = false;
}
else
schreiben.
Muss aber nicht.
:)

Das ist mir jetzt schon ein bisschen unangenehm ... :D Natürlich sollte es das. Danke fürs Korrigieren!!

Bzgl. deines Hinweises? Warum wäre das "besser"? Zwecks der nächsten Berechnung?
 

Neumi5694

Top Contributor
... und weil 'plus' vom Typ boolean ist reicht auch schon 'if(plus) {'...
... und damit ist auch die potentielle Feherquelle von vorneherein nicht mehr vorhanden.

Die Standards beim Benennen von Methoden ermutigen auch zu dieser Schreibweise. Deshalb heißen Boolean Zugriffsmethoden im Normalfall "button.isSelected()" oder "iterator.hasMoreElements()", so kommt man gar nicht auf die Idee, hier nochmal mit Boolean zu vergleichen.

Variablen sollten ebenfalls so benannt werden. Also anstatt "plus" z.B. "plusButtonWasPressed". Ein paar Zeichen mehr schaden niemandem und machen den Code viel verständlicher.
 
Zuletzt bearbeitet:

Wuast

Bekanntes Mitglied
nützlicher Hinweis direkt zu Beginn, bevor ich mir was "schlechtes" angewöhne. :D Werde ich direkt mal überarbeiten.

Ich hab mir jetzt den WindowBuilder geschnappt. Kurze Rückfrage dazu:
Wenn ich jetzt beim Taschenrechner ein Eingabefeld 1 für eine Zahl (als String) habe, einen JButton mit dem Operanden und dann wieder ein Eingabefeld 2, dann funktioniert der ActionHandler bei mir nur, wenn ich zuerst beide Zahlen eingebe und dann z.B. auf das "Plus" klicke. Klar, was zahl er auch sonst in den Double der eingabezahl2 Parsen, wenn noch nichts vorhanden ist. Würdet ihr das dann über einen separaten Thread und der Methode join lösen oder gibt es da andere Möglichkeiten (vielleicht auch über den Builder) die mir unbekannt sind?
 

MarvinsDepression

Bekanntes Mitglied
Ich weiß nicht, ob ich ich da jetzt richtig verstanden habe, aber ich glaube due beziest deine Frage auch die Zeilen 112/113. Hier wird ja zur Laufzeit ein Fehler geworfen, wenn sich der enthaltene String nicht in ein double parsen lässt.
Solche Fehler lassen sich gut in try/catch-Blöcken abfangen. Da bietet es sich auch an, eine eigene Methode zu schreiben z. B.
Java:
double getValue(String tfText) {
    double value = 0.0;
    try {
        value = Double.parseDouble(tfText) ;
    } catch (Exception e) {}
    return value;
}
Das ist jetzt sehr einfach gestrickt und gibt einfach nur 0.0 zurück, wenn der übergebene String leer ist, oder Blödsinn enthält.
 

KonradN

Super-Moderator
Mitarbeiter
nützlicher Hinweis direkt zu Beginn, bevor ich mir was "schlechtes" angewöhne.
Dann möchte ich Dir auch einmal paar Hinweise geben, die Deinen Code vereinfachen / verbessern:

a) Nur ein Befehl pro Zeile (als Faustregel, gibt natürlich Abweichungen wie Aufrufe von Gettern und so.)
Also statt:
Java:
    private JButton add;    boolean plus;
    private JButton sub;    boolean minus;
    private JButton mult;    boolean mal;
    private JButton div;    boolean geteilt;

dann:
Java:
    private JButton add;
    private JButton sub;
    private JButton mult;
    private JButton div;
    boolean plus;
    boolean minus;
    boolean mal;
    boolean geteilt;

b) Enumerations:

Schau Dir auch einmal das Thema Lambda Expressions und Methodenreferenzen an.
Also statt
Java:
    boolean plus;
    boolean minus;
    boolean mal;
    boolean geteilt;

und dann den Zuweisungen wie:
Java:
plus = true;
minus = false; // Das fehlt bei Dir! Bei mehreren Operationen hintereinander musst du vorherige ja deaktivieren!
mal = false;
geteilt = false;

kannst Du eine enum bauen:
Java:
enum Operator { PLUS, MINUS, MAL, GETEILT }

und dann hast Du nur noch eine Variable mit Getter / Setter:
Java:
private Operator operator;

public Operator getOperator() {
    return operator;
}

public void setOperator(Operator operator) {
    this.operator = operator;
}

Und auf Operator könnte man dann ein switch bauen oder so statt deiner if / else if Kombination.

c) Du schreibst Code noch auf eine Art und Weise, die vor Java. üblich war und die einfach unleserlich ist. du verwendest anonyme innere Klassen, z.B. hier:
Java:
        mult.addActionListener(new ActionListener() {

            @Override
            public void actionPerformed(ActionEvent e) {
                mal = true;         
            }
          
        });

Hier solltest Du Dir das Thema Funktionale Interfaces, Lambda Expressions und Methoden Referenzen ansehen.

Bei dem Beispiel wäre z.B. ausreichend (zusammen mit Punkt b):
mult.AddActionListener( e -> setOperator(Operator.MAL) );

Bei mehr wie einem Aufruf kannst Du dann eine Methodenreferenz machen, also bei Deinem Code z.B. bei:
Java:
        rechnungAusfuehren.addActionListener(new ActionListener() {    //anonyme innere Klasse

            @Override
            public void actionPerformed(ActionEvent e) {

                double zahl1 = Double.parseDouble(fieldForNumber1.getText());
                double zahl2 = Double.parseDouble(fieldForNumber2.getText());
              
                double ergebnis = 0;
              
                //warum wird dadurch die Rechnung nicht ausgelöst?
                if (plus = true) {
                    ergebnis = zahl1 + zahl2;
                }
                if (minus = true) {
                    ergebnis = zahl1 - zahl2;
                }
                if (mal = true) {
                    ergebnis = zahl1 * zahl2;
                }
                if (geteilt = true) {
                    ergebnis = zahl1 / zahl2;
                }
                else {
                    System.out.println("Falsche Eingabe.");
                }
                JOptionPane.showMessageDialog(GuiTaschenrechner.this, zahl1 + " " + " "      //hier fehlt noch etwas um das Label für den Operanden einzufügen
                + zahl2 + " = " + ergebnis, "Ergebnis:", JOptionPane.INFORMATION_MESSAGE);     
            }
        } );

Java:
        rechnungAusfuehren.addActionListener(this::rechnungDurchfuehren);

    // ...

    public void rechnungDurchfuehren(ActionEvent e) {

        double zahl1 = Double.parseDouble(fieldForNumber1.getText());
        double zahl2 = Double.parseDouble(fieldForNumber2.getText());

        double ergebnis = 0;

        switch(getOperator()) {
            case PLUS:
                ergebnis = zahl1 + zahl2;
                break;
                
            case MINUS:
                ergebnis = zahl1 - zahl2;
                break;
                
            case MAL:
                ergebnis = zahl1 * zahl2;
                break;
                
            case GETEILT:
                ergebnis = zahl1 / zahl2;
                break;
                
            default:
                System.out.println("Falsche Eingabe.");           
        }
        JOptionPane.showMessageDialog(GuiTaschenrechner.this, zahl1 + " " + " "      //hier fehlt noch etwas um das Label für den Operanden einzufügen
                                      + zahl2 + " = " + ergebnis, "Ergebnis:", JOptionPane.INFORMATION_MESSAGE);     
    }

So ein enum kann auch noch deutlich mehr - eine enum ist halt auch nur eine spezielle Klasse, die sehr viel erlaubt. Man kann den Operatoren auch direkt eine Darstellung geben wenn man wollte. Dann kann man einen Operator nach Darstellung bekommen oder die Darstellung eines Operators:
Java:
import java.util.Objects;

public enum Operator {
    PLUS("+"),
    MINUS("-"),
    MAL("*"),
    GETEILT("/");
    
    private String representation;

    public String getRepresentation() {
        return representation;
    }

    Operator(String representation) {
        this.representation = representation;
    }
    
    public static Operator getFromRepresentation(String representation) {
        for (Operator operator : Operator.values()) {
            if (Objects.equals(representation, operator.getRepresentation())) {
                return operator;
            }
        }
        throw new IllegalArgumentException("Operator " + representation + " ist unbekannt.");
    }
}

Dann kannst Du den Operator bei der Anzeige per operator.getRepresentation() bekommen. Und die Knöpfe für die Operatoren brauchen nur noch eine Methode, die alle Knöpfe benutzen: ActionEvent hat den Sender - damit kann man sich vom Sender den Text geben lassen. Und über Operator.getFromRepresentation bekommt man dann den Operator, den man setzen kann.

Das wären so ein paar Dinge, die mir aufgefallen sind und die man umsetzen könnte.

Wichtig ist am Ende noch: Ich habe mich komplett auf Deinen zuerst gezeigten Code bezogen und keine anderen Vorschläge eingebaut (Einige sind ja eh entfallen durch die Umstellungen). Ganz wichtig ist z.B. der letzte Hinweis von @MarvinsDepression bezüglich Fangen von Exceptions!
 

KonradN

Super-Moderator
Mitarbeiter
Es hat wahrscheinlich einen guten Grund, warum diese Formulierung gewählt wurde
Nicht wirklich. Ich würde es einfach eine Angewohnheit von mir nennen.

Zum einen, um NPE zu vermeiden (hier unkritisch - die NPE, wenn operator null ist habe ich ja auch)

Entstanden ist es bei mir vermutlich durch LawOfDemeter bei PMD:
Eine Verkettung von mehreren Aufrufen a.b().c().... ist teilweise ein Zeichen für unsauberen Code. Bei PMD ist das die Regel "LawOfDemeter": https://pmd.github.io/latest/pmd_rules_java_design.html#lawofdemeter

LawOfDemeter ist eher veraltet und die Regel ist bei mir z.B. eigentlich immer ausgeschlossen, denn zum einen gibt es ja das Builder-Pattern und ab Java 8 die Streams. Das exclude kommt also nicht, weil die Regel so nicht mehr zutrifft sondern weil es zu viele Ausnahmen gibt und man nicht ständig die Regel da im Code ausschließen möchte.

Das wäre da meine Sicht. Deine Schreibweise wäre also aus meiner Sicht auch genau so gut.
 

Wuast

Bekanntes Mitglied
Danke euch!! Enum kam irgendwie überhaupt nicht dran bei mir... Oft gehört, nie verstanden. Muss ich mir mal bei Gelegenheit reinfahren. Die Lambda auch nicht (habe ich mir selber mal ein Video angeschaut zu) und das funktionale Coden (oder wie das heißt) nur im Rahmen der Einführung von Streams. Ich bin ja noch in den Grundlagen, denke, sowas kommt dann nach und nach :) Nochmal zurück zu meiner Frage, weil erstmal bin ich jetzt noch bei den GUIs und da versuche ich zu verstehen, wie ich den Code unabhängig von der Eingabereihenfolge gestalten kann (wie hier in meinem Bsp.) - try&catch ist DAS Werkzeug der Wahl in solchen Situationen?

Ich schau mal, ob wir was einfällt und dann schreibe ich das hier mal rein wenn ich nicht zufrieden bin (wovon ich jetzt schon mal ausgehe hehe)
 

KonradN

Super-Moderator
Mitarbeiter
wie ich den Code unabhängig von der Eingabereihenfolge gestalten kann (wie hier in meinem Bsp.) - try&catch ist DAS Werkzeug der Wahl in solchen Situationen?
Ja und Nein.

Generell sollte man Exceptions nur bei "Ausnahmesituationen" zulassen. Exceptions sollte man nicht für die Programmlogik verwenden.

ABER: Die Logik, wie denn gültige Zahlen aussehen können, ist gar nicht mal so trivial. Da unterstützt Java relativ wie wie z.B. unterschiedliche regionale Einstellungen (Wir haben das Komma bei Dezimalzahlen und den Punkt als Tausender-Trenner, aber das sieht anders aus wie man ja auch am Quellcode sieht, in dem wir ja auch den . als Trenner bei Dezimalzahlen nutzen müssen.)
Daher ist es hier zumindest nicht unüblich, das Parsen einfach zu versuchen um dann eine Exception zu fangen.

Aber generell sollte man sich überlegen, was man macht. Es ist blöd, wenn man einen Knopf drücken kann und das ist dann fehlerhaft weil zu früh oder eine Angabe ist fehlerhaft.
==> Validierung ist hier sehr wichtig. In einer UI ist es üblich, dass man bei Feldern eine Validierung macht:
  • Pflichtfelder sind dann als solche gekennzeichnet
  • wenn etwas ungültiges eingegeben wird, dann wird das kenntlich gemacht.
  • Ein Knopf ist erst dann aktiv, wenn de Voraussetzungen erfüllt sind.

Wie kann sowas dann z.B. aussehen?
  • Bei einem Eingabefeld ist dann ggf. ein Symbol mit einem ? - wenn man da mit der Maus drauf geht, dann bekommt man ein Popup mit einer Information, was dort erwartet wird. (So dies notwendig ist!)
  • Wenn man etwas eingegeben hat, dann wird der Rahmen rot, wenn die Eingabe ungültig ist. Bei einer gültigen Eingabe wechselt es zur ursprünglichen Farbe oder wird grün ... Alternativ auch als separates Symbol, also z.B. ein grüner Haken, wenn eine Eingabe ok ist, ein rot Hinterlegtes ! wenn ein Fehler vorliegt.
  • Und ein Knopf ist nur dann aktiv, wenn alle notwendigen Eingaben da und korrekt sind.
Edit: Das ist natürlich nur ganz grob und oberflächig. Da kommt man dann zum Thema UI/UX und da gibt es viele Bücher zu. Einige Plattformen haben auch Vorgaben, wie etwas aussehen sollte.
 

Wuast

Bekanntes Mitglied
Ja und Nein.

Generell sollte man Exceptions nur bei "Ausnahmesituationen" zulassen. Exceptions sollte man nicht für die Programmlogik verwenden.

ABER: Die Logik, wie denn gültige Zahlen aussehen können, ist gar nicht mal so trivial. Da unterstützt Java relativ wie wie z.B. unterschiedliche regionale Einstellungen (Wir haben das Komma bei Dezimalzahlen und den Punkt als Tausender-Trenner, aber das sieht anders aus wie man ja auch am Quellcode sieht, in dem wir ja auch den . als Trenner bei Dezimalzahlen nutzen müssen.)
Daher ist es hier zumindest nicht unüblich, das Parsen einfach zu versuchen um dann eine Exception zu fangen.

Aber generell sollte man sich überlegen, was man macht. Es ist blöd, wenn man einen Knopf drücken kann und das ist dann fehlerhaft weil zu früh oder eine Angabe ist fehlerhaft.
==> Validierung ist hier sehr wichtig. In einer UI ist es üblich, dass man bei Feldern eine Validierung macht:
  • Pflichtfelder sind dann als solche gekennzeichnet
  • wenn etwas ungültiges eingegeben wird, dann wird das kenntlich gemacht.
  • Ein Knopf ist erst dann aktiv, wenn de Voraussetzungen erfüllt sind.

Wie kann sowas dann z.B. aussehen?
  • Bei einem Eingabefeld ist dann ggf. ein Symbol mit einem ? - wenn man da mit der Maus drauf geht, dann bekommt man ein Popup mit einer Information, was dort erwartet wird. (So dies notwendig ist!)
  • Wenn man etwas eingegeben hat, dann wird der Rahmen rot, wenn die Eingabe ungültig ist. Bei einer gültigen Eingabe wechselt es zur ursprünglichen Farbe oder wird grün ... Alternativ auch als separates Symbol, also z.B. ein grüner Haken, wenn eine Eingabe ok ist, ein rot Hinterlegtes ! wenn ein Fehler vorliegt.
  • Und ein Knopf ist nur dann aktiv, wenn alle notwendigen Eingaben da und korrekt sind.
Edit: Das ist natürlich nur ganz grob und oberflächig. Da kommt man dann zum Thema UI/UX und da gibt es viele Bücher zu. Einige Plattformen haben auch Vorgaben, wie etwas aussehen sollte.
Ja genau in die Richtung soll / muss es ja dann eigentlich gehen. Komme ich da über den WindowBuilder nicht weiter? Ich merke nämlich, dass ich - wenn ich anfange den Code umzuschreiben und versuche, das Problem zu lösen, immer wieder Fehler bekomme, teilweise auch an anderer Stelle (z.B. müssen die zahlenvariablen und die ergebnisvariable final sein wenn die im Action-Block steht...
Jetzt müsste ich ja auch das Parsen der zahl1 und zahl2 werte bei falscher Eingabe über den catch abfangen. das bläht den Code ja unendlich auf, aber so muss es wohl sein :D

Lange Rede wenig Sinn: Ich muss den EventHandler der Buttons für die Operanden und das Gleichzeichen sperren, solange keine zweite Zahl eingegeben wurde!?! Gibt es da eine Möglichkeit über den WindowBuilder, dass ich zwei EventHandler auf einen Knopf packe und das dann im Code anpasse oder so?
 

KonradN

Super-Moderator
Mitarbeiter
Wie weit man mit dem Window Builder kommt, weiss ich nicht. Aber die Oberfläche wird man damit bestimmt gestalten können um dann den Rest im Code zu machen.

z.B. müssen die zahlenvariablen und die ergebnisvariable final sein wenn die im Action-Block steht...
Ich nehme an, dass Du hier von Lambda Expressions redest? Da sollte man nicht mit Blöcken arbeiten. Da ist es besser, den Code in einer Methode zu haben und da hast Du dann viele Probleme nicht (da Du z.B. gar keine lokalen Variablen im Zugriff hast so dass Du da alles über Instanzvariablen machen musst).

Gibt es da eine Möglichkeit über den WindowBuilder, dass ich zwei EventHandler auf einen Knopf packe und das dann im Code anpasse oder so?
Wozu das denn? Es sollte eigentlich nur einen EventHandler geben, der dann etwas fachliches aufruft. Du musst Code halt sauber strukturieren und dann sollte das kein Problem mehr sein.

Evtl. macht es Sinn, wenn Du einmal so ein Projekt (wenn es halbwegs funktioniert) postest und man da dann das etwas umschreibt mit Erläuterungen. Teilweise haben wir das hier ja schon gemacht und da kann man bestimmt noch einiges mehr machen.
 

Wuast

Bekanntes Mitglied
Wie weit man mit dem Window Builder kommt, weiss ich nicht. Aber die Oberfläche wird man damit bestimmt gestalten können um dann den Rest im Code zu machen.


Ich nehme an, dass Du hier von Lambda Expressions redest?
Ne ich meinte den Abschnitt, den der WindowBuilder erzeugt, wenn ich einen EventHandler einfüge^^. Bisschen blöd ausgedrückt
Evtl. macht es Sinn, wenn Du einmal so ein Projekt (wenn es halbwegs funktioniert) postest und man da dann das etwas umschreibt mit Erläuterungen. Teilweise haben wir das hier ja schon gemacht und da kann man bestimmt noch einiges mehr machen.
Ja, ich mach den Taschenrechner mal soweit fertig wie es klappt und poste dann den Code :) Ohne WindowBuilder hat es ja auch soweit funktioniert, aber eben etwas abgesteckter.
 

Wuast

Bekanntes Mitglied
Evtl. macht es Sinn, wenn Du einmal so ein Projekt (wenn es halbwegs funktioniert) postest und man da dann das etwas umschreibt mit Erläuterungen.
So, da es ja eine ganz simple und nicht gerade umfangreiche Geschichte ist poste ich den Code, inkl. Kommentaren bei den Fehlern oder Unklarheiten. Der Rechner funktioniert (Rechenoperationen code-bedingt nur die Addition), stellt mich aber nicht zufrieden.
Freue mich da über Hinweise und Lösungsvorschläge :)

Java:
package winBuild;

import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JLabel;
import java.awt.Font;
import javax.swing.SwingConstants;
import javax.swing.JTextField;
import javax.swing.JButton;
import javax.swing.JFormattedTextField;
import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;

public class Taschenrechner_Gui {

    private JFrame hauptfenster_lyt;
    private JTextField zahlEingabefeld1_txt;
    private JTextField zahlEingabefeld2_txt;


    public static void main(String[] args) {
        EventQueue.invokeLater(new Runnable() {
            public void run() {
                try {
                    Taschenrechner_Gui window = new Taschenrechner_Gui();
                    window.hauptfenster_lyt.setVisible(true);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        });
    }


    public Taschenrechner_Gui() {
        initialize();
    }

    private double ergebnis;

    private void initialize() {
   
        hauptfenster_lyt = new JFrame();
        hauptfenster_lyt.setTitle("Taschenrechner");
        hauptfenster_lyt.setFont(new Font("Dialog", Font.BOLD, 35));
        hauptfenster_lyt.setBounds(100, 100, 450, 300);
        hauptfenster_lyt.getContentPane().setLayout(null);
   
        JLabel headlineTaschenrechner_lbl = new JLabel("Taschenrechner");
        headlineTaschenrechner_lbl.setFont(new Font("Lucida Grande", Font.BOLD, 20));
        headlineTaschenrechner_lbl.setBounds(24, 18, 402, 16);
        hauptfenster_lyt.getContentPane().add(headlineTaschenrechner_lbl);
   
        zahlEingabefeld1_txt = new JTextField();
        zahlEingabefeld1_txt.setText("Zahleneingabe 1");
        zahlEingabefeld1_txt.setBounds(24, 46, 130, 26);
        hauptfenster_lyt.getContentPane().add(zahlEingabefeld1_txt);
        zahlEingabefeld1_txt.setColumns(10);
   
        zahlEingabefeld2_txt = new JTextField();
        zahlEingabefeld2_txt.setText("Zahleneingabe 2");
        zahlEingabefeld2_txt.setColumns(10);
        zahlEingabefeld2_txt.setBounds(296, 46, 130, 26);
        hauptfenster_lyt.getContentPane().add(zahlEingabefeld2_txt);
   
   
        JButton plusWurdeGedrueckt_btn = new JButton("+");
        plusWurdeGedrueckt_btn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
           
                try {
                double zahl1 = Double.parseDouble(zahlEingabefeld1_txt.getText());
                double zahl2 = Double.parseDouble(zahlEingabefeld2_txt.getText());
                //Operations op = new Operations();
                //ergebnis = op.addition(zahl1, zahl2);
                //unnötig oder clear code? Würde ich instinktiv nicht machen...
                ergebnis = zahl1 + zahl2;
                }
            catch (Exception operation) {
                Exceptions exc = new Exceptions();
                exc.exceptionFuerRechenoperation();    //funktioniert, wünschenswert wäre aber, dass der Button inaktiv ist wenn die 2. Zahl fehlt
                }
            }
        });
        plusWurdeGedrueckt_btn.setBounds(147, 46, 26, 29);
        hauptfenster_lyt.getContentPane().add(plusWurdeGedrueckt_btn);
   
        //die folgenden JButtons sind noch funktionslos, gleichen dann im Prinzip dem " + "
        JButton minusWurdeGedrueckt_btn = new JButton("-");
        minusWurdeGedrueckt_btn.setBounds(185, 46, 26, 29);
        hauptfenster_lyt.getContentPane().add(minusWurdeGedrueckt_btn);
   
        JButton malWurdeGedrueckt_btn = new JButton("*");
        malWurdeGedrueckt_btn.setBounds(223, 46, 26, 29);
        hauptfenster_lyt.getContentPane().add(malWurdeGedrueckt_btn);
   
        JButton geteiltWurdeGedrueckt_btn = new JButton("/");
        geteiltWurdeGedrueckt_btn.setBounds(261, 46, 26, 29);
        hauptfenster_lyt.getContentPane().add(geteiltWurdeGedrueckt_btn);
   
        JLabel ergebnisWirdAusgegeben_lbl = new JLabel("Ergebnis");
        ergebnisWirdAusgegeben_lbl.setBounds(296, 242, 130, 16);
        hauptfenster_lyt.getContentPane().add(ergebnisWirdAusgegeben_lbl);
   
        JButton gleichWurdeGedrueckt_btn = new JButton("=");
        gleichWurdeGedrueckt_btn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                    ergebnisWirdAusgegeben_lbl.setText(Double.toString(ergebnis));
                }
        });
        gleichWurdeGedrueckt_btn.setBounds(24, 237, 117, 29);
        hauptfenster_lyt.getContentPane().add(gleichWurdeGedrueckt_btn);
   
    }
}


package winBuild;

import javax.swing.JOptionPane;

public class Exceptions {


    public void exceptionFuerRechenoperation() {
        JOptionPane.showMessageDialog(null, "Fehler. Erst beide Zahlen eingeben, dann den Operanden auswählen.", "ERROR", JOptionPane.ERROR_MESSAGE);
    }
}


//aktuell nicht gebraucht, zwischenzeitl. zum debuggen erstellt, wegen Rückfrage
//zum clean code noch belassen (s. Zeile 77)
package winBuild;

public class Operations {

    public double addition (double zahl1, double zahl2) {
        double ergebnis = zahl1 + zahl2;
        return ergebnis;
    }
}

Edit: Die Anonymen Klassen, die ich hier verwende, baut der Window-Builder automatisch ein. Streams und Lambda-Ausdrücke sind mir zumindest grob ein Begriff, wenngleich ich da noch nicht so fit bin. ^^
 
Zuletzt bearbeitet:

Neumi5694

Top Contributor
Mit den Bezeichnungen der Buttons werde ich nicht so recht glücklich. Ich weiß zwar, dass das auf einen Tip von mir zurückzuführen ist, aber toll find ich's nicht. Buttons sind keine Boolean-Variablen.
Deine Klasse Operations ist so komplett sinnlos.
Diese ist nur dann sinnvoll, wenn es sich um Enums handelt.
Eine von mir aus gesehen bessere Vorgehensweise wäre:
1. die verschiedenen Operationen festlegen (Enum erstellen wie oben beschrieben).
2. deine Buttons machen nichts.
2.a) Wenn du einen aus einer Gruppe von Buttons ausgewählt haben willst und deine Auswahl bei "=" ausgewertet werden soll, dann verwende JToggleButton und füge sie eine ButtonGroup hinzu, damit auch immer nur einer gedrückt sein kann.
2.b) Wenn du hingegen die Operation bei Klick auf den Button setzen willst, dann brauchen die Buttons einen Actionlistener.
Du kannst auch einen für alle Buttons verwenden, der z.B. auf das ActionCommand des gedrückten Buttons reagiert.
Erstellen kannst du sie in diesem Fall auf diese Weise.
Java:
MyConstructor() {
    //ich verwende mal der Einfachkeit halber name als Key und gehe davon aus, dass es keine Buttons mit ungültigem Namen geben kann.
    buttonPlus = new JButton(Operation.Addition.getSymbol());
    buttonPlus.setActionCommand(Operation.Addition.name());
    buttonPlus.addActionListener(this::handleOperationButton);

    buttonMinus = new JButton(Operation.Subtraction.getSymbol());
    buttonMinus.setActionCommand(Operation.Subtraction.name());
    buttonMinus.addActionListener(this::handleOperationButton);
    //noch schöner wird's wenn man eine Methode zum Erstellen eines Buttons verwendet, als Parameter wird die Operation übergeben.
}
private void handleOperationButton(ActionEvent e) {
    this.selectedOperation = Operation.valueOf(e.getActionCommand());
}
private double getEvaluation() {
    //das hier geht erst in neueren Java-Versionen. In älteren muss ein klassisches switch / case verwendet werden mit einzelnen Rückgaben
    return switch (this.selectedOperation) {
            case Addition -> getVal1() + getVal2();
            case Subtraction -> getVal1() - getVal2();
    };
}

private enum Operation {
    Addition("+"), Subtraction("-"),;
    Operation(String symbol) {}
    public String getSymbol(){}
}
 

Wuast

Bekanntes Mitglied
Mit den Bezeichnungen der Buttons werde ich nicht so recht glücklich. Ich weiß zwar, dass das auf einen Tip von mir zurückzuführen ist, aber toll find ich's nicht. Buttons sind keine Boolean-Variablen.
Deine Klasse Operations ist so komplett sinnlos.
Diese ist nur dann sinnvoll, wenn es sich um Enums handelt.
Eine von mir aus gesehen bessere Vorgehensweise wäre:
1. die verschiedenen Operationen festlegen (Enum erstellen wie oben beschrieben).
2. deine Buttons machen nichts.
2.a) Wenn du einen aus einer Gruppe von Buttons ausgewählt haben willst und deine Auswahl bei "=" ausgewertet werden soll, dann verwende JToggleButton und füge sie eine ButtonGroup hinzu, damit auch immer nur einer gedrückt sein kann.
2.b) Wenn du hingegen die Operation bei Klick auf den Button setzen willst, dann brauchen die Buttons einen Actionlistener.
Du kannst auch einen für alle Buttons verwenden, der z.B. auf das ActionCommand des gedrückten Buttons reagiert.
Erstellen kannst du sie in diesem Fall auf diese Weise.
Java:
MyConstructor() {
    //ich verwende mal der Einfachkeit halber name als Key und gehe davon aus, dass es keine Buttons mit ungültigem Namen geben kann.
    buttonPlus = new JButton(Operation.Addition.getSymbol());
    buttonPlus.setActionCommand(Operation.Addition.name());
    buttonPlus.addActionListener(this::handleOperationButton);

    buttonMinus = new JButton(Operation.Subtraction.getSymbol());
    buttonMinus.setActionCommand(Operation.Subtraction.name());
    buttonMinus.addActionListener(this::handleOperationButton);
    //noch schöner wird's wenn man eine Methode zum Erstellen eines Buttons verwendet, als Parameter wird die Operation übergeben.
}
private void handleOperationButton(ActionEvent e) {
    this.selectedOperation = Operation.valueOf(e.getActionCommand());
}
private double getEvaluation() {
    //das hier geht erst in neueren Java-Versionen. In älteren muss ein klassisches switch / case verwendet werden mit einzelnen Rückgaben
    return switch (this.selectedOperation) {
            case Addition -> getVal1() + getVal2();
            case Subtraction -> getVal1() - getVal2();
    };
}

private enum Operation {
    Addition("+"), Subtraction("-"),;
    Operation(String symbol) {}
    public String getSymbol(){}
}
An den Enums komme ich wohl nicht vorbei :D Ich schau mir das Thema nochmal genauer an. Danke für die Tips.
Bzgl. der Buttons: Find ich auch nicht so pralle, aber plus_btn ist auch nicht schön?!
JToggle ist ein schöner Hinweis! :) Ich gucke! den Actionlistener habe ich ja schon.
 

Neumi5694

Top Contributor
plus_btn ist auch nicht schön?!
Für den Anfang schon ok, wenn auch nicht den Konventionen entsprechend (Stichwort: LowerCamelCase, richtiger wäre plusBtn).
Nur so was wie "minusWurdeGedrueckt_btn" hat mich meine Plomben spüren lassen.

Natürlich funktioniert auch alles ohne Enums, aber die machen den Code einfach viel besser lesbar und sie sind perfekt um eine begrenzte Menge an Optionen zu verwalten. Ist immer nur ein Wert aus der Menge möglich, reicht eine einzelne Variable. Sind mehre möglich, verwendet man ein EnumSet.
 

Wuast

Bekanntes Mitglied
hab ich so übernommen aus einem YT-Erklärvideo. Ging wohl darum, dass man direkt erkennt, welchen component man da eingefügt hat. Hätte dann aber wohl korrekt plusBtn_btn sein müssen, was aber auch kacke ist :D
ich bleibe dann bei dem ausgeschriebenen, das fällt mir am leichtesten.
Nur so was wie "minusWurdeGedrueckt_btn" hat mich meine Plomben spüren lassen.
:D gut.
aber wie war denn dann dein Vorschlag gemeint?
Variablen sollten ebenfalls so benannt werden. Also anstatt "plus" z.B. "plusButtonWasPressed". Ein paar Zeichen mehr schaden niemandem und machen den Code viel verständlicher.
 

Neumi5694

Top Contributor
Das
hab ich so übernommen aus einem YT-Erklärvideo. Ging wohl darum, dass man direkt erkennt, welchen component man da eingefügt hat. Hätte dann aber wohl korrekt plusBtn_btn sein müssen, was aber auch kacke ist :D
ich bleibe dann bei dem ausgeschriebenen, das fällt mir am leichtesten.

:D gut.
aber wie war denn dann dein Vorschlag gemeint?
"plusBtn_btn sein" wäre komplett daneben, da 2 mal "btn" vorkommt. Deshalb "plusBtn" oder "btnPlus" (worum es sich handelt steht für gewöhnlich am Anfang, nicht am Ende). Java ist keine Scriptsprache (verwechsle Java nie mit JavaScript), Regeln aus Skriptsprachen passen nicht. Du bist jetzt in der vorkompilierten objektorientierten Programmierung, hier gelten andere Richtlinien.

Mein Vorschlag war genau so gemein, wie er geschrieben war. Einen Ja/Nein Zustand, also eine BOOLEAN-Vairable kann man sinnvollerweise mit "subtractionWasSelected" oder "isSubtractionButtonSelected" bezeichnen, da sie einen Boolean-Wert beschreibt und "was" oder "is" oder "has" einen Ja/Nein Zustand beschreiben.
Der Button selbst hingegen ist aber kein Zustand, deshalb passt dort eine solche Bezeichnung nicht. Es handelt sich um einen Button, der Name wäre also "buttonSubtraction" oder bei einem ToggleButton "toggleButtonSubtraction"
Ob der Togglebutton gedrückt ist oder nicht, kriegst du mit "toggleButtonSubtraction.isSelected()" raus. Hier hast du wieder einen Ja/Nein Zustand, es befindet sich ein "is" in der Benennung des Zustands.

ps: Die Unart, Unterstriche zu verwenden, hab ich mir selbst auch nicht ganz abgewöhnt, das sollte aber nur bei Konstanten gemacht werden, die komplett in Großbuchstaben geschrieben sind, damit man sie noch lesen kann. In allen anderen Fällen kommt CamelCase oder LowerCamelCase zum Einsatz.
 
Zuletzt bearbeitet:

Wuast

Bekanntes Mitglied
Das

"plusBtn_btn sein" wäre komplett daneben, da 2 mal "btn" vorkommt. Deshalb "plusBtn" oder "btnPlus" (worum es sich handelt steht für gewöhnlich am Anfang, nicht am Ende). Java ist keine Scriptsprache (verwechsle Java nie mit JavaScript), Regeln aus Skriptsprachen passen nicht. Du bist jetzt in der vorkompilierten objektorientierten Programmierung, hier gelten andere Richtlinien.

Mein Vorschlag war genau so gemein, wie er geschrieben war. Einen Ja/Nein Zustand, also eine BOOLEAN-Vairable kann man sinnvollerweise mit "subtractionWasSelected" oder "isSubtractionButtonSelected" bezeichnen, da sie einen Boolean-Wert beschreibt und "was" oder "is" oder "has" einen Ja/Nein Zustand beschreiben.
Der Button selbst hingegen ist aber kein Zustand, deshalb passt dort eine solche Bezeichnung nicht. Es handelt sich um einen Button, der Name wäre also "buttonSubtraction" oder bei einem ToggleButton "toggleButtonSubtraction"
Ob der Togglebutton gedrückt ist oder nicht, kriegst du mit "toggleButtonSubtraction.isSelected()" raus. Hier hast du wieder einen Ja/Nein Zustand, es befindet sich ein "is" in der Benennung des Zustands.

ps: Die Unart, Unterstriche zu verwenden, hab ich mir selbst auch nicht ganz abgewöhnt, das sollte aber nur bei Konstanten gemacht werden, die komplett in Großbuchstaben geschrieben sind, damit man sie noch lesen kann. In allen anderen Fällen kommt CamelCase oder LowerCamelCase zum Einsatz.
Okay ich glaube da habe ich dich am Anfang einfach missverstanden bzw. war doch mit der reinen Namensbezeichnung eigentlich auf dem richtigen Weg :) Alles gut, danke für die Rückmeldung. Habe das alles verstanden und keine Sorge, Java auch nicht mit JavaScript verwechselt ;)
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
Hilde22 Neu Start JButton einfügen Java Basics - Anfänger-Themen 2
M JButton setBackground() färbt nicht den ganzen Knopf Java Basics - Anfänger-Themen 4
C JButton reagiert nicht auf actionListener Java Basics - Anfänger-Themen 15
G jButton führt Main Methode nicht richtig aus Java Basics - Anfänger-Themen 3
J Jbutton blinkt Java Basics - Anfänger-Themen 5
C JButton Text 2 Mal ändern funktioniert nicht Java Basics - Anfänger-Themen 8
E JButton und JTextField Java Basics - Anfänger-Themen 1
V_Fynn03 Erste Schritte JButton funktioniert nicht trotz richtiger Methode. Java Basics - Anfänger-Themen 17
J Erste Schritte if Abfrage von JButton in 2. Klasse Java Basics - Anfänger-Themen 27
J Erste Schritte Actionlistener für tbar/ JButton Java Basics - Anfänger-Themen 15
krgewb Icon von JButton ändern Java Basics - Anfänger-Themen 1
P JButton -Arrays Java Basics - Anfänger-Themen 4
A JButton in anderer Klasse bearbeiten. Java Basics - Anfänger-Themen 2
L Erste Schritte JButton reagiert nicht Java Basics - Anfänger-Themen 5
S Bild über JButton legen Java Basics - Anfänger-Themen 3
V Einem JButton anweisungen geben Java Basics - Anfänger-Themen 4
D Methoden JButton und JLabel in einer Methode erstellen Java Basics - Anfänger-Themen 5
F Interface JButton von anderer Klasse hinzufügen Java Basics - Anfänger-Themen 2
J JButton macht was er will Java Basics - Anfänger-Themen 3
D JButton soll Farbe von JTextfield ändern Java Basics - Anfänger-Themen 5
H JButton - Wechsel der Textfarbe alle 500ms Java Basics - Anfänger-Themen 10
G KeyListener und JButton vertragen sich nicht Java Basics - Anfänger-Themen 1
N JButton anpassen Java Basics - Anfänger-Themen 3
S JButton soll für bestimmte Zeit verschwinden Java Basics - Anfänger-Themen 5
schoenosrockos JButton füllt immer das ganze frame Java Basics - Anfänger-Themen 1
D JButton in JDialog mit Action belgen Java Basics - Anfänger-Themen 6
V JButton einer anderen Klasse übergeben? Java Basics - Anfänger-Themen 6
F JButton [] mit Werten hinterlegen Java Basics - Anfänger-Themen 10
M Code um per jButton ein neues Fenster zu öffnen Java Basics - Anfänger-Themen 3
A weiter JButton Fehler Java Basics - Anfänger-Themen 3
W JTable mit einem JButton-Array füllen Java Basics - Anfänger-Themen 4
S JCombobox und JButton verknüpfen Java Basics - Anfänger-Themen 6
V wie kann ich eine Schleife pausieren, bis ein Jbutton gedrückt wird ? Java Basics - Anfänger-Themen 17
N Erste Schritte JButton reagiert nur einmal. Java Basics - Anfänger-Themen 12
S JButton Java Basics - Anfänger-Themen 2
A Farben wechseln mit JButton Java Basics - Anfänger-Themen 2
S Farbe eine Zeile in JTable ändern, wenn JButton geklickt wurd Java Basics - Anfänger-Themen 4
F Funktion eines JButton in einen Vektor verlagern Java Basics - Anfänger-Themen 4
S Interface JButton etc. wird in JFrame mit paint() nicht angezeigt Java Basics - Anfänger-Themen 6
A Labels Inner JButton Event Erstellbar? Java Basics - Anfänger-Themen 3
K JButton alles zurücksetzen Java Basics - Anfänger-Themen 1
U JButton: Beschriftung ueber Variable zuweisen Java Basics - Anfänger-Themen 6
S JButton erscheint erst bei Mouseover Java Basics - Anfänger-Themen 10
S JButton mit ActionListener Java Basics - Anfänger-Themen 5
S JDK installieren JButton BorderPoints?! Java Basics - Anfänger-Themen 7
E Problem mit erben von JButton Java Basics - Anfänger-Themen 7
J Bei Hinzufügen von JButton Programm langsam Java Basics - Anfänger-Themen 3
J Verknüpfung von JButton to JTextField Java Basics - Anfänger-Themen 4
S Jbutton per Passworteingabe aktivieren Java Basics - Anfänger-Themen 2
G über JButton Action einen anderen Button verändern Java Basics - Anfänger-Themen 7
H JButton - Icon(.png) aus resources laden Java Basics - Anfänger-Themen 23
M Hintergrundbild für JButton Java Basics - Anfänger-Themen 6
A jbutton - icon linksbündig, text zentriert Java Basics - Anfänger-Themen 10
M Input/Output JFrame mit JButton und JTextfield Java Basics - Anfänger-Themen 114
J Hilfe bei JButton Java Basics - Anfänger-Themen 6
A JButton[] und String[] in doppelter For-Schleife Java Basics - Anfänger-Themen 4
W JButton in gleiche Größe bringen Java Basics - Anfänger-Themen 4
pg1337 JButton zuschneiden Java Basics - Anfänger-Themen 3
T Modales JDialog schliessen mit JButton Java Basics - Anfänger-Themen 2
D JButton Array setBackground Java Basics - Anfänger-Themen 2
F JButton wie selektierter JTabbebPane-Header Java Basics - Anfänger-Themen 7
G jButton bei Klick String +1 Java Basics - Anfänger-Themen 5
C OOP Java JButton mit Funktion belegen Java Basics - Anfänger-Themen 3
S JButton wird nicht angezeigt Java Basics - Anfänger-Themen 14
C JButton.getIcon() != null Java Basics - Anfänger-Themen 3
E JButton-Text wird in Schleife nicht geändert Java Basics - Anfänger-Themen 4
F welches Layout für JButton-Liste verwenden Java Basics - Anfänger-Themen 6
T JButton Text ändern Java Basics - Anfänger-Themen 4
L JButton erscheint nur mit pack() Java Basics - Anfänger-Themen 3
U Passwort auf JButton setzen. Java Basics - Anfänger-Themen 2
E JButton Hintergrund / Rahmen entfernen? Java Basics - Anfänger-Themen 4
L Bild auf einem JButton Java Basics - Anfänger-Themen 4
K JButton.setText Problem Java Basics - Anfänger-Themen 6
M JButton und DisabledIcon Java Basics - Anfänger-Themen 2
K jButton zur Laufzeit hinzufügen Java Basics - Anfänger-Themen 22
A GUI - JButton problem! Java Basics - Anfänger-Themen 5
M JButton selbst nachprogrammieren Java Basics - Anfänger-Themen 3
A JButton Textrahmen Java Basics - Anfänger-Themen 7
A Platzierung eines JButton Java Basics - Anfänger-Themen 4
D JButton oder ImageIcon klickt "langsam" Java Basics - Anfänger-Themen 5
E JButton klassenübergreifend nutzen? Java Basics - Anfänger-Themen 6
R Liste graphischer Objekte z.B. JButton dynamisch erstellen Java Basics - Anfänger-Themen 13
J JList Inhalt nach JButton Klick aktualisieren Java Basics - Anfänger-Themen 8
S JButton trotz Box-Layout skalieren Java Basics - Anfänger-Themen 6
P JButton identifizieren Java Basics - Anfänger-Themen 8
K Funktion zu einem JButton hinzufügen Java Basics - Anfänger-Themen 27
D HTML Text von jButton disablen Java Basics - Anfänger-Themen 2
E Auf JButton in Arraylist zugreifen Java Basics - Anfänger-Themen 6
E Andere Form eines JButton Java Basics - Anfänger-Themen 17
A JButton ActionListener nach einmaligem Ausführen zurücksetzen Java Basics - Anfänger-Themen 13
B JButton Größe einstellen? Java Basics - Anfänger-Themen 3
E Zeilenumbruch in JButton mit Variable Java Basics - Anfänger-Themen 2
A JButton erscheint nicht (BlueJ) Java Basics - Anfänger-Themen 2
M JButton sieht komisch aus :-) Java Basics - Anfänger-Themen 5
B JPanel über JButton umändern Java Basics - Anfänger-Themen 9
D JButton transparent bekommen? Java Basics - Anfänger-Themen 5
H JButton Unsichtbar Java Basics - Anfänger-Themen 7
R JTextField mittels JButton in Konsole ausgeben Java Basics - Anfänger-Themen 2
J Variable die bei JButton Clicks mitzählt Java Basics - Anfänger-Themen 9
Developer_X JButton removt sich selbst Java Basics - Anfänger-Themen 32

Ähnliche Java Themen

Neue Themen


Oben