ActionListener und mathematische Methoden

[mwb]

Hallo zusammen,

ich bin noch recht neu im JAVA Umfeld und beginne aktuell meine ersten Anwendungen zu schreiben. Zwischenzeitlich habe ich mich an Swing und AWT herangestatet und entwerfe derzeit einen Taschenrechner (Ich benötige etwas konkretes, an dem ich Lernen kann).

Bisher funktionierte der Rechner zuverlässig, Grundrechenarten, Wurzeln, etc. kann ich wunderbar damit berechnen. Vor kurzem habe ich mich daran gemacht, Potenzen zu integrieren, aber hier stoße ich auf ein Problem: Mittels eines ActionListeners (siehe Code Bsp) ermittel ich, welche Taste gedrückt wurde und übergebe dies an einen String. Je nach Erfordernis forme ich den Typ (meistens via Double.parseDouble(Variable) ) nochmals um. Wenn ich jedoch die Methode Math.pow nutzen möchte, stehe ich vor dem Problem, dass hier zwei Double Werte benötigt werden. Ich habe es schon versucht mittels Hilfsvariablen bzw. auch Arrays zu lösen. Mein Grundgedanke ist, dass der ActionListener in ein Array der Länge zwei jeweils einen Input übermittelt. Da ich allerdings alles mit einem String abfrage, funktioniert dies nicht.

//Gekürzerter Code mit dem Wesentlichen für bessere Lesbarkeit

ActionListener mathm=new MathmAction();            //Action Listener für mathematische Funktionen


addButton("pot", mathm);



    private class MathmAction implements ActionListener{
        public void actionPerformed(ActionEvent event){
            String mathm=event.getActionCommand();
            String val1=display.getText();
            Double val2=Double.parseDouble(val1);
            if(mathm.equals("e^x")){
                double val3=Math.exp(val2);
                String val4=String.valueOf(val3);                            //Konvertierung von val3 für Rückgabe ans Display: String
                display.setText(val4);
                result=val3;        
               }else if(mathm.equals("pot")){
                double [] x= new double[2];
                    String abc=val1;
                    x[0]=Double.parseDouble(abc);
                    System.out.println("Der Wert des Arrays an der Stelle 0 beträgt: " +x[0]);
                    x[1]=Double.parseDouble(val1);
                    System.out.println("Der Wert des zweiten Arrays an der Stelle 1 beträgt: " +x[1]);
                String ergebnis=String.valueOf(Math.pow(x[0], x[1]));
                display.setText(ergebnis);
            }

Der obige Codeauszug ist eine aktuelle Arbeitsdatei, daher auch noch die printlns, um gewisse Werte in der Konsole zur Fehlerbehebung besser zu kontrollieren.

Wie deutlich zu erkennen wird ein Klick initial im String val1 verarbeitet. val2 wird genutzt für die Konvertierung zu Double Werten. val1 und val2 werden hierbei für die meisten Tasten genutzt und stehen daher noch vor der if-Schleife, damit der Code so übersichtlicher wird.

Aus meiner Sicht besteht das Problem darin, dass jede Eingabe mittels einer Taste in val1 initial gespeichert wird und ich daher im Falle einer Potenz nicht unterscheiden kann, welche Eingabe zum ersten double Wert und welche zum Zweiten gehören soll.
Die Idee mit den Arrays kam mir durch meine ersten Übungen an der Konsole vpn Eclipse, hier konnte ich mittels eines Scanners mehrere Werte abfragen, welche dann in das Array gespeichert wurden.

Meine Frage lautet daher: Gibt es eine Möglichkeit, wie ich die benötigten Werte (double 1 und double 2) unterscheiden kann? Mir gehen so langsam die Ideen aus.

Ich hoffe, dass mir ein alter Hase evtl. ein wenig Hilfestellung geben kann (und sei es nur mit einem Verweis an die richtige Stelle in der API (diese überfordert mich aktuell noch ein wenig)).

Danke & Gruß

mwb

 

[mwb]

Hallo,

nochmal ich. Eine wichtige Sache habe ich vergessen: Möchte ich bspw. aktuell das Ergebnis von 2^2 berechnen, kommt es dazu, dass sowohl in x[0] als auch in x[1] 2.0 steht. Für das Beispiel 2^2 mag dies noch hinkommen, aber für 2^3,...2^x ist es nicht mehr so passend.

Vielleicht erklärt dies meine Frage besser.

 

[JStein52]

Warum merkst du dir nicht in einer Variablen den Zustand deines Taschenrechners, z.B. "erwarte ersten Operanden", "erwarte zweiten Operanden" und was sonst noch so wichtig ist. Dann weisst du was die aktuelle Eingabe für eine Bedeutung hat und kannst sie einer entsprechenden Variablen zuordnen. Und sobald die Ergebnistaste gedrückt wird fängt dein Rechner wieder von vorne an. Ich habe mir jetzt deinen Code nicht sooo genau angeschaut wie das da einzubauen wäre, sollte aber nicht so ein Problem sein.

 

[mwb]

Nun ja, ich habe einen solchen Ansatz schon mal versucht, allerdings scheine ich da immer noch etwas falsch zu machen, da der Rechner bei jeder Zahleneingabe dann einen Haufen Fehler wirft. Der entsprechende Codeteil lautete:

String input=event.getActionCommand();                        //Tastatureingaben werden zu String formatiert
            /*
             * Abfangen der letzten zwei Zahleneingaben
             */
          
               for(int i=0; i<2; i++){
                   if(start==true){                                                 //Prüfung ob Zahlentaste gedrückt wurde
                     
                       String hilf1;                                                  //Hilfsvariable 1 für Listener Input
                       String hilf2;                                                  //Hilfsvariable 2 für Listener Input
                     
                       if(i==0){
                       hilf1=event.getActionCommand();
                       System.out.println("im ersten durchgang:" +hilf1);
                       i++;
                       }else{
                           if(hilf1!=null)
                           {
                           hilf2=event.getActionCommand();
                           System.out.println("im zweiten durchgang: " +hilf2);
                           i++;
                       }
                   }
               }
             }

Dieser Teil lehnt sich an meine ersten Erfahrungen mit Schleifen an. Die println Anweisung dient nur dazu für mich initial festzustellen, ob alles in den richtigen Variablen gespeichert wurde.

Neben den Fehlern die das produziert hat habe ich den Lösungsansatz aus einem weiteren Grund nicht verfolgt: Mir ist nicht klar, wie ich die Variablen bei erreichen des Wertes i=1 wieder mit neuen Werten belegen kann. Wenn i=2 eintreffen würde, müsste ja i=0 vom gespeicherten Wert befreit werden, i=1 müsste zu i=0 werden und i=2 zu i=1, damit ich wieder die aktuellen letzten Zahleneingaben habe.

Hat irgendwer eine Idee? Egal ob Variablen, Arrays, etc, ich bin über jeden Hinweis dankbar

 

[JStein52]

Ok. Ganz verstanden habe ich es noch nicht. Kannst du mal kurz sagen wie deine Benutzeroberfläche aussieht ? Du hast vermutlich einen Button für jede Ziffer und dann welche für Komma (oder Punkt), für verschiedene Operatoren wie +, - etc. Und einen zum Löschen/Clear des Rechners ?? Und an allen diesen Buttons hört der oben prinzipiell gezeigte ActionListener ? Oder hört der nur auf die Operatorbuttons ?

Und wie ist dann der Ablauf z.B. einer y^x - Berechnung wird zuerst y eingegeben, dann die y^x-Taste gedrückt dann x eingegeben ?? Was ist das spezielle Problem bei y^x ? Bei einer addition werden doch auch zwei Werte benötigt ?

 

[mwb]

Hi,

sorry, ich habe mir das verkürzte Darstellen angewöhnt, in diesem Kontext ist es sicherlich jedoch nicht förderlich. Daher nachfolgend mein ganzer Code (Hinweis: Es könnten noch Artefakte vorhanden sein, es ist ein lebendes Dokument, in der finalen Version überarbeite ich es erneut von oben bis unten).

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

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;


public class Calculator {
       public static void main(String[] args)  {
          CalculatorFrame frame = new CalculatorFrame();
          frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
          frame.setVisible(true);
       }
    }

    class CalculatorFrame extends JFrame
    {
       public CalculatorFrame()
       {
          setTitle("Calculator");
          CalculatorPanel panel = new CalculatorPanel();
          add(panel);
          pack();
       }
    }

   
    class CalculatorPanel extends JPanel{
  
    JButton display;    //Das Ausgabedisplay des Rechners
    JPanel panel;
    boolean start;        //Parameter zum Feststellen von Zahleneingaben
    double result;        //Parameter für Schleifen
    double store;        //Variable zum Speichern von Werten
    String lastCommand;    //Parameter für die Berechnung
    String mathm;
  
       public CalculatorPanel()
       {
           setLayout(new BorderLayout());
         
           display=new JButton("0");                //Zeigt initial eine Null im Display an
           display.setEnabled(false);                //Verhindert, dass der Nutzer Eingaben über das Display vornehmen kann
           add(display, BorderLayout.NORTH);        //Positioniert das Display
         
           result=0;                                //Wird für die Berechnungsmethode als Wert benötigt
           lastCommand="=";
           start=true;                                //Parameter für Schleifen
         
           panel=new JPanel();
           panel.setLayout(new GridLayout(6,5));    //Erzeugung einer 4x4 Fläche für die Buttons
         
           ActionListener insert = new InsertAction();        //ActionListener für Zahleneingaben
           ActionListener command = new CommandAction();    //Action Listener für Operatoreingaben
           ActionListener del=new DeleteAction();            //Action Listener für Werte löschen
           ActionListener sto=new StoreAction();            //Action Listener zum Speichern von werten
           ActionListener rcl=new RecallAction();            //Action Listener zum Upload von Werte
           ActionListener pm=new PmAction();                //Action Listener für Plus/Minus Tausch
           ActionListener mathm=new MathmAction();            //Action Listener für mathematische Funktionen
         
                 addButton("del", del);
                 addButton("sto", sto);
                 addButton("rcl", rcl);
                 addButton("+/-", pm);
               
                 addButton("7", insert);
              addButton("8", insert);
              addButton("9", insert);
              addButton("/", command);
       
              addButton("4", insert);
              addButton("5", insert);
              addButton("6", insert);
              addButton("*", command);
       
              addButton("1", insert);
              addButton("2", insert);
              addButton("3", insert);
              addButton("-", command);
       
              addButton("0", insert);
              addButton(".", insert);
              addButton("=", command);
              addButton("+", command);
            
              addButton("e^x", mathm);
              addButton("sqrt", mathm);
              addButton("cbrt", mathm);
              addButton("10^x", mathm);
         
           add(panel, BorderLayout.CENTER);            //Positionierung des Panels
         
       }

    private void addButton(String label, ActionListener listener) {
        JButton button=new JButton(label);            //Zuweisung des Parameters Label
        button.addActionListener(listener);            //Zuweisung des Parameter ActionListener
        panel.add(button);                            //Zuweisung der Buttons zum Panel
    }
  
    /*
     * Nachfolgend: ActionListener "insert" erzeugt Display Ausgabe
     */
  
    private class InsertAction implements ActionListener{
        public void actionPerformed(ActionEvent event){
            String input=event.getActionCommand();                        //Tastatureingaben werden zu String formatiert
            /*
             * Abfangen der letzten zwei Zahleneingaben
             */
          
               for(int i=0; i<2; i++){
                   if(start==true){
                     
                       String hilf1;
                       String hilf2;
                     
                       if(i==0){
                       hilf1=event.getActionCommand();
                       System.out.println("im ersten durchgang:" +hilf1);
                       i++;
                       }else{
                           if(hilf1!=null)
                           {
                           hilf2=event.getActionCommand();
                           System.out.println("im zweiten durchgang: " +hilf2);
                           i++;
                       }
                   }
               }
             }
          
            if(start==true){
                display.setText("");                                    //Das Display wird zunächst geleert
                start=false;
            }
            display.setText(display.getText() + input);                    //Übernimmt ggfs. bestehende Ziffern und fügt neue hinzu
        }
    }
  
    /*
     * Nachfolgend: ActionListener "command" startet die Berechnung
     * Abfangen des Falles: Erste Eingabe ein Minus für negative Zahlen
     * Umwandlung des Displayinhaltes in Typ Double für den Berechnungsteil
     */
  
    private class CommandAction implements ActionListener{
        public void actionPerformed(ActionEvent event){
            String command=event.getActionCommand();                    //Tastatureingaben werden zu String formatiert
            /*
             * Abfang des Falles: Erste Eingabe ist ein negatives Vorzeichen
             */
            if(start==true){
                if(command.equals("-")){
                    display.setText(command);                              //Das negative Vorzeichen wird gesetzt
                    start=false;
                }else{
                    lastCommand=command;                              
                }
              
            }else{
                calculate(Double.parseDouble(display.getText()));        //Umwandlung des Display Inhalts in den Typ Double
                lastCommand=command;
                start=true;
            }
        }
    }
  
    /*
     * Nachfolgend: ActionListener "del" zum Bereinigen der Werte
     */
  
    private class DeleteAction implements ActionListener{
        public void actionPerformed(ActionEvent event){
            String del=event.getActionCommand();
            result=0;
            start=true;
            display.setText("");
        }
    }
  
    /*
     * Nachtfolgend: ActionListener "sto" zum Speichern von Werten
     */
  
    private class StoreAction implements ActionListener{
        public void actionPerformed(ActionEvent event){
            String sto=event.getActionCommand();
            store=Double.parseDouble(display.getText());
        }
    }
  
    /*
     * Nachfolgend: ActionListener "rcl" zum Upload von Werten
     */
  
    private class RecallAction implements ActionListener{
        public void actionPerformed(ActionEvent event){
            String rcl=event.getActionCommand();
            String recall=String.valueOf(store);
            display.setText(display.getText() +recall);
        }

    }
  
    /*
     * Nachfolgend: ActionListener "pm" für Plus/Minus Vorzeichen
     *
     */
  
    private class PmAction implements ActionListener{
        public void actionPerformed(ActionEvent event){
            String pm=event.getActionCommand();
            String val1=display.getText();                                    //Der Wert des Displays wird ausgelesen: String
            Float val2=Float.valueOf(val1);                                    //Konvertierung val1 in Float um mehrmaliges Ausführen zu ermöglichen
            val2 *=-1;      
            String val3=String.valueOf(val2);                                //Konvertierung von val2 in String für Rückgabe ans Display
            display.setText(val3);
            result = Double.parseDouble(val3);                                //Wertzuweisung an result um bei weiteren Berechnungen zu berücksichtigen: double

        }
    }
  
    /*
     * Nachfolgend: AchtionListener "mathm" für mathematische Funktionen
     */
    private class MathmAction implements ActionListener{
        public void actionPerformed(ActionEvent event){
            String mathm=event.getActionCommand();
            String val1=display.getText();
            Double val2=Double.parseDouble(val1);
            if(mathm.equals("e^x")){
          
          
                double val3=Math.exp(val2);
                String val4=String.valueOf(val3);                            //Konvertierung von val3 fpr Rückgabe ans Display: String
                display.setText(val4);
                result=val3;                                                //Wertzuweisung an result um bei weiteren Berechnungen zu berücksichtigen: double
            }else if(mathm.equals("sqrt")){
                //System.out.println(val1);
                //System.out.println(val2);
                double val5=Math.sqrt(val2);                  
                String val6=String.valueOf(val5);                            //Konvertierung von val5 für Rückgabe ans Display: String
                display.setText(val6);
                result=val5;                                                //Wertzuweisung an result um bei weiteren Berechnungen zu berücksichtigen: double
                //System.out.println(result);
            }else if(mathm.equals("cbrt")){
                //System.out.println(val1);
                //System.out.println(val2);
                double val7=Math.cbrt(val2);
                String val8=String.valueOf(val7);                            //Konvertierung von val für Rückgabe ans Display: String
                display.setText(val8);                                      
                result=val7;                                                //Wertzuweisung an result um bei weiteren Berechnungen zu berücksichtigen: double
                //System.out.println(val8);
            }else if(mathm.equals("10^x")){
                double val9=val2;
                double fixed10=10;
                double val11=Math.pow(fixed10, val9);
                String val12=String.valueOf(val11);
                display.setText(val12);
                result=val11;
            }

        }
    }
  
  
    /*
     * Nachfolgend: Der eigentliche Berechnungsteil
     */
  
       public void calculate(double x)
       {
          if (lastCommand.equals("+")) result += x;
          else if (lastCommand.equals("-")) result -= x;
          else if (lastCommand.equals("*")) result *= x;
          else if (lastCommand.equals("/")) result /= x;
          else if (lastCommand.equals("=")) result = x;
          display.setText("" + result);
       }
}

Ich hoffe, das bringt etwas mehr Klarheit. Danke schon mal für die Zeit, die du dir nimmst.

 

[mwb]

Als kurze Zwischenmeldung:

Ich habe nun mehr einen Workaround gefunden, mit dessen Hilfe ich einen zweiten Input erstellen kann. Hierfür nutze ich ein JOptionPane Input Dialog. Glücklich bin ich allerdings nicht mit dieser Lösung, da der Nutzer bei jeder mathematischen Funktion (welche zwei Inputs benötigt) dieses Fenster angezeigt bekommen muss. Auf Dauer nervt das schon ein wenig.

Die nächsten Tage werde ich noch ein wenig mit Variablen experimentieren, welche die jeweiligen Inputs der Listener (Input und Command) richtig verarbeiten. Im ersten Schritt ist zu gewährleisten, dass die Eingaben der Zahlen (Input Listener) zusätzlich in eine Hilfsvariable geschrieben werden, auf die der Command Listener zusätzlich (oder ein neuer?) zugreifen kann. Nachdem der Operatorbutton geklickt wurde soll bei der neuen Zahleneingabe überprüft werden, ob Hilfsvariable 1 bereits genutzt wird und dann Hilfsvariable 2 verwendet werden (wahrscheinlich mit If-Schleifen realisiert). Die daraus resultierenden Werte müssten noch geparsed und dann irgendwie weitergegeben werden.
Worüber ich mir allerdings noch nicht ganz im Klaren bin: Wie kann ich gewährleisten, dass nachdem die Operatortaste geklickt wurde und der zweite Wert vorliegt, anschließend alles geparsed, dann an Math.pow geht und nach erfolgter Ausgabe die Hilfsvariablen 1 und 2 mit null belegt werden (ohne dass ich den selben Button erneut klicken muss bzw. den Button für =).

Mal sehen ob ich hier auf eine Lösung komme. Für jede Anregung bin ich wie immer dankbar.

 

[JStein52]

Hallo,
du haqst doch mal geschrieben die Grundrechenarten funktionieren ? Ich habe mir deinen Code noch nicht in der Hinsicht angeschaut aber das sind doch auch math. Operationen die zwei Eingaben benötigen ? Warum machst du es bei y^x (z.B.) nicht ganz genau so ? Ich hatte jetzt gedacht man gibt zuerst den ersten Operanden ein, dann drückt man auf die Operatortaste, dann gibt man den zweiten Operanden ein, dann auf "=" ???? Wobei der erste Operand natürlich auch das Ergebnis einer vorhergehenden Operation (oder halt 0.0 falls nichts eingegeben wurde) sein kann.

Ist das so ? Du kannst doch immer den ersten Operanden im Display halten, wenn eine Operatortaste gedrückt wird wandert das in eine Variable "double operand1", du merkst dir die Operatortaste in einer Variablen, wartest auf den zweiten Operanden, wieder zunächste nur im Display und wenn erneut auf eine Operatortaste gedrückt wird führst du die letze Oparation aus, Operand1 hast du in einer Variablen, Operand2 holst du dir aus dem Display. Ich überlege heute nachmittag noch mal ein bisschen genauer

 

[mwb]

Hallo,

die Grundrechenarten funktionieren in der Tat. Die Grundlagen hierfür bilden nachfolgend:

1) Deklaration result=0; (im Calculator Panel)
2) Berechnung im calculate(double x)

Quasi: Vor der ersten eingabe hat result den Initialwert von null. Du addierst 3 hinzu (result +=x) und result hat nun das Ergebnis 3.

Dass du beim Klicken deinen Operanden im Display siehst ergibt sich aus:

display.setText(display.getText() + input) im InsertAction.

Das Programm ist aktuell so ausgelegt, dass alles nur mittels result abläuft, d.h. keine separate Speicherung der Variablen. Ursprünglich erschien mir das Zweckmäßig, ich wollte einen simplen Rechner für die vier Grundrechenarten schreiben, welcher mittels +=, etc. funktioniert (quasi das zuvor Gelernte anwenden). Aber wie es immer ist, es reichte mir nicht mehr nachdem es funktionierte und ich wollte mehr. Evtl. muss ich mir über ein Re-design der Berechnung Gedanken machen, evtl. hilft das. Dein Vorschlag klingt interessant, ich würde mich freuen, wenn du ihn etwas ausführen könntest, zu 100% kann ich dir noch nicht folgen.

 

[mwb]

Hallo,

als kurze Rückmeldung: Mir war es am Wochenende möglich das Problem zu lösen. Die Lösung bestand darin, einen neuen ActionListener einzuführen sowie die Ergebnisse durch eine neue Methode berechnen zu lassen, der ursprüngliche, problembehaftete, Ansatz bestand darin, die vorhandene Methode zur Berechnung zu nutzen.

Seitdem funktioniert es Bestens.

 

[JStein52]

Ok, Glückwunsch. Wie du gemerkt hast kam ich am Wochenende im Gegensatz zu dir nicht dazu mir das Problem nochmal anzuschauen

 

[mwb]

Garkein Problem,

ein wenig schlechtes Wetter + Urlaub auf Balkonien können manchmal verfügbare Zeit schaffen. Ganz im Ernst, ich freue mich, dass ich mir die Lösung erarbeitet habe. Ein Problem erledigt, neue schon am Horizont sichtbar, allerdings hier dann in anderen Postings.

 

[mwb]

Hallo zusammen,

nachdem ich die API nochmal eingehender studiert und ein wenig rumprobiert habe, konnte ich entsprechende Methoden erstellen, um das von mir gewünschte Ergebnis zu erhalten.

 /*
                    * Implementing Switching Methods for panel content
                    */
               
                    //Implementing Switch pnlCenter for switching GridLayout
                   void switchpnlCenter(boolean x){
                        if(x){
                            deletepnlCenterStandard();
                        }else{
                            deletepnlCenterEnhanced();
                   
                        }
                   }
                 
                 //Implementing Method to delete pnlCenterEnhanced content
                   void deletepnlCenterEnhanced(){
                       pnlCenter.removeAll();
                       activateEnhancedButtonset();
                   }
                
                 //Implementing Method to delete pnlCenterStandard content
                   void deletepnlCenterStandard(){
                       pnlCenter.removeAll();
                       activateStandardButtonset();
                   }
                
                 //Implementing Method to draw enhanced buttonset
                   void activateEnhancedButtonset(){
                       pnlCenter.setLayout(new GridLayout(7,5));
                          addButton("del", handling);
                             addButton("sto", handling);
                             addButton("rcl", handling);
                             addButton("+/-", handling);
                            
                             addButton("7", insert);
                          addButton("8", insert);
                          addButton("9", insert);
                          addButton("/", command);
                    
                          addButton("4", insert);
                          addButton("5", insert);
                          addButton("6", insert);
                          addButton("*", command);
                    
                          addButton("1", insert);
                          addButton("2", insert);
                          addButton("3", insert);
                          addButton("-", command);
                    
                          addButton("0", insert);
                          addButton(".", insert);
                          addButton("=", command);
                          addButton("+", command);
                         
                          addButton("e^x", command2);
                          addButton("sqrt", command2);
                          addButton("cbrt", command2);
                          addButton("10^x", command2);
                         
                          addButton("pow", command);
                          pnlCenter.validate();
                          repaint();
                          pack();

                   }
                  
                   //Implementing Method to draw standard buttonset
                     void activateStandardButtonset(){
                            pnlCenter.setLayout(new GridLayout(4,4));
                           
                            addButton("7", insert);
                            addButton("8", insert);
                            addButton("9", insert);
                            addButton("/", command);
                           
                            addButton("4", insert);
                            addButton("5", insert);
                            addButton("6", insert);
                            addButton("*", command);
                           
                            addButton("1", insert);
                            addButton("2", insert);
                            addButton("3", insert);
                            addButton("-", command);
                           
                            addButton("0", insert);
                            addButton(".", insert);
                            addButton("=", command);
                            addButton("+", command);
                           
                             pnlCenter.validate();
                             repaint();
                             pack();
                        
                     }

Damit kann ich nun mehr gewährleisten, dass das Buttonset nicht nur einmal getauscht wird, sondern stets, wenn die Checkbox betätigt wird.

Allerdings habe ich noch eine abschließende Frage: Ich versuche meinen Displaybutton nun auf die Größe meines Center Panels anzupassen. Hierzu versuche ich es mittels pnl.Center.getWidth(), allerdings erhalte ich hier einen Wert von 0 zurückgegeben, ein Fehler wird jedoch nicht ausgegeben. Welche Alternative kann ich anwenden, um meinen Displaybutton auf die Größe des größten Panels zu bringen? setSize verlangt ja sowohl Höhe als auch Länge, ich möchte jedoch nur über der länge arbeiten.

 

[mwb]

Ups, grade gemerkt, falscher Beitrag :/