# RPN-Rechner Speicher-Verwaltung



## vienna_devil (28. Dez 2010)

Hallo!

Für die aktuelle Hausaufgabe müssen wir einen RPN-Rechner mit Speicher schreiben. Das ist soweit auch schon erledigt, allerdings kämpfe ich derzeit noch ganz verbissen mit dem Speicher...

Also der Rechenr ansich funktioniert wunderbar (addition und subtraktion zumindest, rest hab ich noch nicht getestet), allerdings sobald man daten aus dem speicher abrufen möchte (und damit rechnet) sollen diese aus dem speicher gelöscht, also überschrieben werden - und genau das funktioniert nicht richtig...


```
import javax.swing.*;
import java.awt.*;

public class Rechner_4 extends JFrame
{
    
    private JPanel jContentPane = null;
    private JTextField jTextField_text = null;
    private JButton jButton_enter = null;
    private JButton jButton_addieren = null;
    private JButton jButton_subtrahieren = null;
    private JButton jButton_multiply = null;
    private JButton jButton_divide = null;

    double zahl1 = 0;
    double zahl2 = 0;
    double[] erg = {0,0,0,0,0};

    //Diverse Konstrukroren und die methode Initialize
    //Werden Verwendet um das Fenster zu erzeugen
    public Bsp1_0926514_4() throws HeadlessException
    {
        super();
        initialize();
    }
    public Rechner_4(GraphicsConfiguration gc)
    {
        super(gc);
        initialize();
    }
    public Rechner_4(String title) throws HeadlessException
    {
        super(title);
        initialize();
    }
    public Rechner_4(String title, GraphicsConfiguration gc)
    {
        super(title, gc);
        initialize();
    }

    //Erzeugt das Fenster
    private void initialize()
    {
        this.setSize(200, 400);
        this.setResizable(false);
        this.setContentPane(getJContentPane()); //??
        this.setTitle("Calculator");
    }

    //Erzeugt das komplette Panel, bzw den Inhalt
    private JPanel getJContentPane()
    {
        if(jContentPane == null)
        {
            jContentPane = new JPanel();
            jContentPane.add(getJTextField_text(), null);
            jContentPane.add(getJButton_enter(), null);
            jContentPane.add(getJButton_addieren(), null);
            jContentPane.add(getJButton_subtrahieren(), null);
            jContentPane.add(getJButton_multiplizieren(), null);
            jContentPane.add(getJButton_dividieren(), null);
        }
        return jContentPane;
    }

    //Erzeugt das Text-Feld  "jTextField_text"
    private JTextField getJTextField_text()
    {
        if(jTextField_text == null)
        {
            try{
                jTextField_text = new JTextField();
                jTextField_text.setPreferredSize(new Dimension(100, 50));
                jTextField_text.setText("0");
            }
            catch(java.lang.Throwable e)
            {
                //Do Nothing
            }
        }

        return jTextField_text;
    }

    private JButton getJButton_enter()
    {
        if(jButton_enter == null)
        {
            try
            {
                jButton_enter = new JButton();
                jButton_enter.setPreferredSize(new Dimension(150, 50));
                jButton_enter.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_enter.setText("ENTER");
                jButton_enter.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodEnter();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_enter;
    }
    private JButton getJButton_addieren()
    {
        if(jButton_addieren == null)
        {
            try
            {
                jButton_addieren = new JButton();
                jButton_addieren.setPreferredSize(new Dimension(150, 50));
                jButton_addieren.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_addieren.setText("+");
                jButton_addieren.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodAddieren();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_addieren;
    }
    private JButton getJButton_subtrahieren()
    {
        if(jButton_subtrahieren == null)
        {
            try
            {
                jButton_subtrahieren = new JButton();
                jButton_subtrahieren.setPreferredSize(new Dimension(150, 50));
                jButton_subtrahieren.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_subtrahieren.setText("-");
                jButton_subtrahieren.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodSubtrahieren();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_subtrahieren;
    }
    private JButton getJButton_multiplizieren()
    {
        if(jButton_multiply == null)
        {
            try
            {
                jButton_multiply = new JButton();
                jButton_multiply.setPreferredSize(new Dimension(150, 50));
                jButton_multiply.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_multiply.setText("x");
                jButton_multiply.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodMultiplizieren();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_multiply;
    }
    private JButton getJButton_dividieren()
    {
        if(jButton_divide == null)
        {
            try
            {
                jButton_divide = new JButton();
                jButton_divide.setPreferredSize(new Dimension(150, 50));
                jButton_divide.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_divide.setText("/");
                jButton_divide.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodDividieren();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_divide;
    }

    public static void main(String args[])
    {
        Bsp1_0926514_4 thisClass = new Bsp1_0926514_4();
        //Close-Handling
        thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //sichtbar
        thisClass.setVisible(true);
    }


    private void methodEnter()
    {
        //beschreibt zahl1
        try
        {
            zahl1 = Double.parseDouble(jTextField_text.getText());
            jTextField_text.setText("0");
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }

    private void methodAddieren()
    {
        //beschreibt zahl2
        try
        {
            zahl2 = Double.parseDouble(jTextField_text.getText());

            if(zahl1 == 0 || zahl2 == 0)
                speicherAbrufen();
            
            //calculate-Funktion
            double ergebnis = calculate(0, zahl1, zahl2);
            jTextField_text.setText(Double.toString(ergebnis));
            zahl1 = 0; zahl2 = 0;
            

            //zwischenergebnis in erg-array speichern
            zwischenspeichern(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodSubtrahieren()
    {
        //beschreibt zahl2
        try
        {
            zahl2 = Double.parseDouble(jTextField_text.getText());

            if(zahl1 == 0 || zahl2 == 0)
                speicherAbrufen();
            
            //calculate-Funktion
            double ergebnis = calculate(1, zahl1, zahl2);
            jTextField_text.setText(Double.toString(ergebnis));
            zahl1 = 0; zahl2 = 0;
            

            //zwischenergebnis in erg-array speichern
            zwischenspeichern(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodMultiplizieren()
    {
        //beschreibt zahl2
        try
        {
            zahl2 = Double.parseDouble(jTextField_text.getText());

            if(zahl1 == 0 || zahl2 == 0)
                speicherAbrufen();
            
            //calculate-Funktion
            double ergebnis = calculate(2, zahl1, zahl2);
            jTextField_text.setText(Double.toString(ergebnis));
            zahl1 = 0; zahl2 = 0;
            

            //zwischenergebnis in erg-array speichern
            zwischenspeichern(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodDividieren()
    {
        //beschreibt zahl2
        try
        {
            zahl2 = Double.parseDouble(jTextField_text.getText());

            if(zahl1 == 0 || zahl2 == 0)
                speicherAbrufen();
            
            //calculate-Funktion
            double ergebnis = calculate(3, zahl1, zahl2);
            jTextField_text.setText(Double.toString(ergebnis));
            zahl1 = 0; zahl2 = 0;
            

            //zwischenergebnis in erg-array speichern
            zwischenspeichern(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }

    private double calculate(int operator, double z1, double z2)
    {
        if(operator == 0)
            return ((z1) + (z2));
        else if(operator == 1)
            return ((z1) - (z2));
        else if(operator == 2)
            return ((z1) * z2);
        else if(operator == 3)
            return ((z1) / (z2));
        else
            return 0;
    }

    //zwischenspeichern der ergebnisse
    private void zwischenspeichern(double wert)
    {
        for(int i= 0; i<5; i++)
        {
            if(erg[i] == 0)
                erg[i] = wert;
        }
    }
    
    //speichert den wert explizit an eine stelle, und schreibt nachstehende 
    //werte nach vor um speicher freizugeben
    private void einzelPlatzLoeschen(int stelle)
    {        
        for(int i=stelle; i<4; i++)
        {
            erg[i] = erg[i+1];
        }
        erg[4] = 0;        
    }

    private void speicherAbrufen()
    {
        if(zahl1 == 0 && zahl2 == 0)
        {
            for(int i = 0; i > -1; i--)
            {
                if(erg[i] != 0)
                {
                    zahl1 = erg[i];
                    einzelPlatzLoeschen(i);
                    zahl2 = erg[i];
                    einzelPlatzLoeschen(i);
                    i = 0;
                }
            }
        }
        else if(zahl1 == 0 && zahl2 != 0)
        {
            for(int i = 0; i> -1; i--)
            {
                if (erg[i] != 0)
                {
                    zahl1 = erg[i];
                    einzelPlatzLoeschen(i);
                    i=0;
                }
            }
        }
        else if(zahl1 != 0 && zahl2 == 0)
        {
            for(int i = 0; i> -1; i--)
            {
                if(erg[i] != 0)
                {
                    zahl2 = erg[i];
                    einzelPlatzLoeschen(i);
                    i=0;
                }
            }
        }
    }
    
    
}
```

Das Problem würde ich persönlich eher im Bereich der Methode speicherAbrufen() sehen, eventuell auch bei der Methode einzelPlatzLoeschen(), die hier aufgerufen werden soll...
speicherAbrufen() wird mal nur gestartet, wenn auch eine der eingegebenen Zahlen 0 ist - also anscheinend keine Zahl an diese stelle geschrieben wurde.
In dem Fall soll dann die "untereste" (neueste, am Feld mit dem höchsten Stellenwert befindliche) Zahl ausgewählt werden, und an Stelle der nicht-vorhandenen Zahl eingesetzt werden (genau das macht die Methode speicherAbrufen())

Hier nochmal die Methode einzeln:


```
private void speicherAbrufen()
    {
        if(zahl1 == 0 && zahl2 == 0)
        {
            for(int i = 0; i > -1; i--)
            {
                if(erg[i] != 0)
                {
                    zahl1 = erg[i];
                    einzelPlatzLoeschen(i);
                    zahl2 = erg[i];
                    einzelPlatzLoeschen(i);
                    i = 0;
                }
            }
        }
        else if(zahl1 == 0 && zahl2 != 0)
        {
            for(int i = 0; i> -1; i--)
            {
                if (erg[i] != 0)
                {
                    zahl1 = erg[i];
                    einzelPlatzLoeschen(i);
                    i=0;
                }
            }
        }
        else if(zahl1 != 0 && zahl2 == 0)
        {
            for(int i = 0; i> -1; i--)
            {
                if(erg[i] != 0)
                {
                    zahl2 = erg[i];
                    einzelPlatzLoeschen(i);
                    i=0;
                }
            }
        }
    }
```

Diese Methode speicherAbrufen() soll jetzt aber auch gleich, sofern ein Speicher abgerufen wurde, diesen überschreiben - also wieder einen Platz im Speicher freimachen (der Wert an dieser Stelle wurde ja bereits weiterverarbetiet und muss daher nicht länger aufbewahrt werden)
Das geschieht - oder soll geschehen - in der Methode einzelPlatzLoeschen(int), der mitgegeben wird, welcher Platz des Speichers eigentlich gelöscht werden soll, und ab diesem dann immer den nächten Platz eine Stelle "nach vorne" schreibt, und die höchste Stelle im Speicher auf 0 (leer) setzt.


```
private void einzelPlatzLoeschen(int stelle)
    {        
        for(int i=stelle; i<4; i++)
        {
            erg[i] = erg[i+1];
        }
        erg[4] = 0;        
    }
```

Ich hoffe die Funktionsweisen sind jetzt ausreichend Klar beschrieben - jetzt noch eien kleine Problem Beschreibung:

Angenommenes Beispiel:
1 ENTER                ---  zahl1 = 1
1 +                      ---  zahl2 = 1
calculate(1+1) = 2  --- erg[0] = 2
1 +                      --- zahl2 = 1
calculate(2+1)=3   --- (zahl1 ist ja 0 -> zahl1 = erg[0] = 2 -> erg[0] wird frei gemacht - erg[0] = 0) erg[0] = 3
1 +                      --- zahl2 = 1
calculate(3+1)=4   --- erg[0] = 4 (siehe oben)
_____________________________________________________________
genau hier passiert dann der Fehler, das eben nocht 3+1 = 4 gerechent wird, sondern wieder 2+1=3
daraus schließe ich, das der Fehler nicht im Speicher-Abruf (der Funktioniert ja zumindest 1 mal) liegt, sondern im Freimachen bzw neu Beschreiben des Speichers

Ich bitte daher bitte ausdrücklich nicht um eine Lösung des Problems, sondern nur um einen Vorschlag was denn schief gegangen sein könnte bzw wie ich das Problem beheben könnte - die eigentliche Lösung würde ich aber schon gerne selbst schreiben =)

lg vienna_devil

PS:
ich weiß, das die Speicherverwaltung noch keine Ausnahmebehandlung vorsieht, was passiert wenn der Speicher bereits voll geschrieben ist - dazu muss ich mir auch noch eien sinnvolle lösung überlegen


----------



## MQue (28. Dez 2010)

Schau mal, in welcher Methode genau das Problem liegt, 
ich würde mir auch gedanken machen, ob du nicht eine eigene Frame- Klasse und eine eigene Logik- Klasse machst - dann wird das ganze übersichtilicher.


----------



## vienna_devil (7. Jan 2011)

ok.. ich hab das ganze mal überarbeitet und bin beim nachlesen / googeln auf die stack-klasse gestossen, die ja eigentlich genau das machen sollte was ich mit dem array, zwischenspeichern, speicher abrufen etc bewirken wollte...

folglich hab ich sie gleich mal eingebaut, hab allerdings weiterhin ähnliche probleme:


```
import javax.swing.*;
import java.awt.*;
import java.util.*;


public class test extends JFrame
{

    private JPanel jContentPane = null;
    private JTextField jTextField_text = null;
    private JButton jButton_enter = null;
    private JButton jButton_addieren = null;
    private JButton jButton_subtrahieren = null;
    private JButton jButton_multiply = null;
    private JButton jButton_divide = null;

    //erzeugt den neuen Stack.
    Stack<Double> s = new Stack<Double>();

    //Diverse Konstrukroren und die methode Initialize
    //Werden Verwendet um das Fenster zu erzeugen

//.....................
// Buttons etc. der übersicht wegen entfernt!
// ....................    


    public static void main(String args[])
    {
        Bsp1_0926514_4 thisClass = new Bsp1_0926514_4();
        //Close-Handling
        thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //sichtbar
        thisClass.setVisible(true);
    }


    private void methodEnter()
    {
        //beschreibt zahl1
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));
            jTextField_text.setText("");
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }

    private void methodAddieren()
    {
        //beschreibt zahl2
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));

            double ergebnis = calculate(0,s.pop(),s.pop());

            //zwischenergebnis in erg-array speichern
            s.push(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodSubtrahieren()
    {
        //beschreibt zahl2
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));

            double ergebnis = calculate(1,s.pop(),s.pop());

            //zwischenergebnis in erg-array speichern
            s.push(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodMultiplizieren()
    {
        //beschreibt zahl2
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));

            double ergebnis = calculate(3,s.pop(),s.pop());

            //zwischenergebnis in erg-array speichern
            s.push(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodDividieren()
    {
        //beschreibt zahl2
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));

            double ergebnis = calculate(4,s.pop(),s.pop());

            //zwischenergebnis in erg-array speichern
            s.push(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }

    private double calculate(int operator, double z1, double z2)
    {
        if(operator == 0)
            return ((z1) + (z2));
        else if(operator == 1)
            return ((z1) - (z2));
        else if(operator == 2)
            return ((z1) * z2);
        else if(operator == 3)
            return ((z1) / (z2));
        else
            return 0;
    }
}
```

also wie ihr hier seht, hab ich mal zu gunsten der übersichtlichkeit die ganzen buttons usw aus dem code genommen, der vollständige code steht am ende des posts dann noch...

ich hoffe mal ich hab die Klasse Stack richtig verstanden:
s.push() legt ein neues Objekt an die oberste Stelle des Stacks,
s.pop() nimmt das oberste objekt und returned es (verarbeitung) + löscht es aus dem stack
[s.peek() würde nur das oberste objekt returnen, ohne es zu löschen]

Folglich sollte also mein Programm-Ablauf so aussehen, das mit zuerst eine zahl mit ENTER in den stack geschoben wird - s.push(zahl);

Dann wird bei drücken einer Rechen-Taste zuerst die Zahl aus dem Textfeld wieder in den Stack geschoben - s.push(zahl);
Anschließend werden beide zahlen an die calculate()-Methode übergeben, wobei sie dabei nacheinander wieder aus dem Stack entfernt werden. - mit calculate(int operator, s.pop(), s.pop());
Dadurch sollte der Stack ja wieder leer sein, weil beide Werte die übergeben wurden wieder rausgelöscht wurden.
Das Ergebnis wird danach wieder mit s.push() in den Stack geschoben.
Soweit funktioniert es auch noch - allerdings kommt dann beim 2. Programm-Durchlauf ein Fehler ins Spiel, den ich leider wieder nicht so ganz genau eingrenzen kann, da er für mich einfach nicht nachvollziehbar ist.

Darum hier ein bespielhafter Programmdurchlauf:
1 ENTER -- stack "an Stelle 0 ist 1"
2 + ------- stack "an Stelle 1 ist 2"
= 3 ------- stack 0 und 1 wird gelöscht, stack "an Stelle 0 ist 3"
(würde man jetzt + drücken wäre das nächste ergebnis natürlich 6, weil 3 ja dann 2 mal im stack steht und addiert wird - passt also soweit noch)
7 + ------- stack an stelle 1 wird 7
= 10 ------ stack 0 und 1 werden wieder gelöscht, stack 0 wird 10
5 + ------- stack an stelle 1 wird 5
= 15 (8)------------------------------------ FEHLER!

Genau hier ist dann eben der Fehler, das im 3. durchlauf des Programms nicht 10 + 5 (also das vorherige ergebnis + 5), sondern 3 + 5 gerechnet wird (also das vor-vorherige ergebnis + 5).

Da bin ich jetzt eben an dem Punkt, wo ich nicht mehr durchblicke, wieso funktioniert der Ablauf 2 mal, aber beim 3. mal macht er Probleme?


EDIT:
vergessen den kompletten Code anzuhängen

```
import javax.swing.*;
import java.awt.*;
import java.util.*;

public class test extends JFrame
{

    private JPanel jContentPane = null;
    private JTextField jTextField_text = null;
    private JButton jButton_enter = null;
    private JButton jButton_addieren = null;
    private JButton jButton_subtrahieren = null;
    private JButton jButton_multiply = null;
    private JButton jButton_divide = null;

    double zahl1 = 0;
    double zahl2 = 0;
    double[] erg = {0,0,0,0,0};

    //erzeugt den neuen Stack.
    Stack<Double> s = new Stack<Double>();

    //Diverse Konstrukroren und die methode Initialize
    //Werden Verwendet um das Fenster zu erzeugen
    public test() throws HeadlessException
    {
        super();
        initialize();
    }
    public test(GraphicsConfiguration gc)
    {
        super(gc);
        initialize();
    }
    public test(String title) throws HeadlessException
    {
        super(title);
        initialize();
    }
    public test(String title, GraphicsConfiguration gc)
    {
        super(title, gc);
        initialize();
    }

    //Erzeugt das Fenster
    private void initialize()
    {
        this.setSize(200, 400);
        this.setResizable(false);
        this.setContentPane(getJContentPane()); //??
        this.setTitle("Calculator");
    }

    //Erzeugt das komplette Panel, bzw den Inhalt
    private JPanel getJContentPane()
    {
        if(jContentPane == null)
        {
            jContentPane = new JPanel();
            jContentPane.add(getJTextField_text(), null);
            jContentPane.add(getJButton_enter(), null);
            jContentPane.add(getJButton_addieren(), null);
            jContentPane.add(getJButton_subtrahieren(), null);
            jContentPane.add(getJButton_multiplizieren(), null);
            jContentPane.add(getJButton_dividieren(), null);
        }
        return jContentPane;
    }

    //Erzeugt das Text-Feld  "jTextField_text"
    private JTextField getJTextField_text()
    {
        if(jTextField_text == null)
        {
            try{
                jTextField_text = new JTextField();
                jTextField_text.setPreferredSize(new Dimension(100, 50));
                jTextField_text.setText("0");
            }
            catch(java.lang.Throwable e)
            {
                //Do Nothing
            }
        }

        return jTextField_text;
    }

    private JButton getJButton_enter()
    {
        if(jButton_enter == null)
        {
            try
            {
                jButton_enter = new JButton();
                jButton_enter.setPreferredSize(new Dimension(150, 50));
                jButton_enter.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_enter.setText("ENTER");
                jButton_enter.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodEnter();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_enter;
    }
    private JButton getJButton_addieren()
    {
        if(jButton_addieren == null)
        {
            try
            {
                jButton_addieren = new JButton();
                jButton_addieren.setPreferredSize(new Dimension(150, 50));
                jButton_addieren.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_addieren.setText("+");
                jButton_addieren.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodAddieren();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_addieren;
    }
    private JButton getJButton_subtrahieren()
    {
        if(jButton_subtrahieren == null)
        {
            try
            {
                jButton_subtrahieren = new JButton();
                jButton_subtrahieren.setPreferredSize(new Dimension(150, 50));
                jButton_subtrahieren.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_subtrahieren.setText("-");
                jButton_subtrahieren.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodSubtrahieren();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_subtrahieren;
    }
    private JButton getJButton_multiplizieren()
    {
        if(jButton_multiply == null)
        {
            try
            {
                jButton_multiply = new JButton();
                jButton_multiply.setPreferredSize(new Dimension(150, 50));
                jButton_multiply.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_multiply.setText("x");
                jButton_multiply.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodMultiplizieren();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_multiply;
    }
    private JButton getJButton_dividieren()
    {
        if(jButton_divide == null)
        {
            try
            {
                jButton_divide = new JButton();
                jButton_divide.setPreferredSize(new Dimension(150, 50));
                jButton_divide.setFont(new Font("Arial", Font.BOLD, 10));
                jButton_divide.setText("/");
                jButton_divide.addActionListener(
                    new java.awt.event.ActionListener()
                    {
                       public void actionPerformed(java.awt.event.ActionEvent e)
                       {methodDividieren();}});
            }
            catch(Exception e)
            {
                //Do Nothing
            }
        }
        return jButton_divide;
    }

    public static void main(String args[])
    {
        Bsp1_0926514_4 thisClass = new Bsp1_0926514_4();
        //Close-Handling
        thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        //sichtbar
        thisClass.setVisible(true);
    }


    private void methodEnter()
    {
        //beschreibt zahl1
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));
            jTextField_text.setText("");
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }

    private void methodAddieren()
    {
        //beschreibt zahl2
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));

            double ergebnis = calculate(0,s.pop(),s.pop());

            //zwischenergebnis in erg-array speichern
            s.push(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodSubtrahieren()
    {
        //beschreibt zahl2
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));

            double ergebnis = calculate(1,s.pop(),s.pop());

            //zwischenergebnis in erg-array speichern
            s.push(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodMultiplizieren()
    {
        //beschreibt zahl2
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));

            double ergebnis = calculate(3,s.pop(),s.pop());

            //zwischenergebnis in erg-array speichern
            s.push(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }
    private void methodDividieren()
    {
        //beschreibt zahl2
        try
        {
            s.push(Double.parseDouble(jTextField_text.getText()));

            double ergebnis = calculate(4,s.pop(),s.pop());

            //zwischenergebnis in erg-array speichern
            s.push(ergebnis);
        }
        catch(Exception e)
        {
            //Fehlerbehandlung
        }
    }

    private double calculate(int operator, double z1, double z2)
    {
        if(operator == 0)
            return ((z1) + (z2));
        else if(operator == 1)
            return ((z1) - (z2));
        else if(operator == 2)
            return ((z1) * z2);
        else if(operator == 3)
            return ((z1) / (z2));
        else
            return 0;
    }
}
```


----------

