# UPN Taschenrechner



## mexas450 (7. Jun 2014)

Hallo Leute,

sollen in der Uni ein Taschenrechner Programm schreiben. Komme jetzt aber irgendwie nicht weiter. Wir sollten die Methoden next(); und empty(); aus dem Scanner in eine eigene class "myScanner" schreiben. Bin jetzt soweit das die Berechnungen soweit funktionieren, aber das Problem was besteht ist das mir meinen Stack immer ausgibt. Er soll aber nur einmal angezeigt werden. Ausgabe Momentan schaut so aus:

Willkommen:
<1 2 +
Stack: [1.0,0.0,0.0]
<Stack: [2.0,1.0,0.0]
<Stack: [3.0,0.0,0.0]
<

Es sollte lt. Vorgabe aber so aussehen:

Willkommen:
<1 2 +
Stack: [3.0,0.0,0.0]
<

Danke schon mal für Tipps und Tricks für die Lösung!!!

Hier mal was ich bis jetzt so hinbekommen habe:

[Java]
package SWT1;                                                                   // package SWT1

public class Main                                                                // Beginn Class-Ma
{
    public static void main(String[] args)                                      // Beginn Main-Methode
    {
        myScanner sc = new myScanner();
        Stack meinStack = new Stack();                                          // Stack mit Namen "meinStack" wird erstellt
        String in;
        boolean b;

        System.out.println("Willkommen:");                                      // Bildschirmausgabe "Willkommen" 
        do
        {
            System.out.print("<");
            in = sc.next();
            b = sc.empty();

            if(in.matches("[-+]?[.,0-9]+[-+eE0-9]*"))                           // Überprüfung der ersten Stelle auf Vorzeichen und zweite auf Zahl
            {
                meinStack.push(Double.parseDouble(in));                         // Umwandeln des Strings in einen Double-Wert
            }                                                                   // Ablage der Variablem auf "meinStack"    

            meinStack.Rechenoperationen(in);                                    // Methode-Rechenoperation   
            meinStack.Befehlsoperationen(in);                                   // Methode-Befehlsoperationen

            if ( b == true)
            {
                meinStack.println();
            }                                                                   // Methode-println
        }
        while((in.compareTo("end") != 0));                                      // Ende der Wiederholbarkeits-Schleife durch "end" 
        System.out.println("Programm beendet!!!");                              // Bildschirmausgabe "Programm beendet!!!"
    }                                                                           // Ende Main-Methode
}    
[/Java]

[Java]
package SWT1;

public class Stack                                                              // Beginn der "Stack-Classe"
{
     private double x = 0;                                                      // 1. Variable im Stack
     private double y = 0;                                                      // 2. Variable im Stack
     private double z = 0;                                                      // 3. Variable im Stack
     private double mem = 0;                                                    // Hilfsvariable für "internen Speicher"
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////    
public void push(double in)                                                     // Beginn Methode "push" ablegen auf Stack
{                                                                               // Eintragung muss verkehrt herum sein, sonst Stack gleiche Variable
    z = y;                                                                      // Weitergabe des Wertes y an z
    y = x;                                                                      // Weitergabe des Wertes x an y                
    x = in;                                                                     // Weitergabe des Wertes in an x
}                                                                               // Ende Methode "push" ablegen auf Stack
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public void execute(double ergebnis)                                            // Beginn Methode "execute" 
{                                                                                  
    y = z;                                                                      // Schiebt das ergebnis auf platz X und lässt
    z = 0;                                                                      // Variablen nachrutschen
    x = ergebnis;
}                                                                               // Ende Methode "execute"
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     
public void Rechenoperationen (String in)                                       // Beginn Methode "Rechenoperation"
{
    if(in.compareTo("+") == 0)                                                  // Übereinstimmung des Operator "+" auf Gleichheit  
    {                                                                           
                                                                                // Addiert die beiden oberen Einträge des Stacks,
         execute(x+y);                                                          // entfernt die Einträge vom Stack und
                                                                                // speichert das Ergebnis auf dem Stack.        
    }
    else if(in.compareTo("-") == 0)                                             // Übereinstimmung des Operator "-" auf Gleichheit
    {                                        
                                                                                // Subtrahiert die beiden oberen Einträge
         execute(y-x);                                                          // des Stacks (y - x), entfernt die Einträge
                                                                                // vom Stack und speichert das Ergebnis auf dem Stack.
    }
    else if(in.compareTo("*") == 0)                                             // Übereinstimmung des Operator "*" auf Gleichheit
    {                                        
                                                                                // Multipliziert die beiden oberen Einträge
         execute(x*y);                                                              // des Stacks, entfernt die Einträge vom
                                                                                // Stack und speichert das Ergebnis auf dem Stack.
    }
    else if(in.compareTo("/") == 0)                                             // Übereinstimmung des Operator "/" auf Gleichheit
    {                                        
                                                                                // Dividiert die beiden oberen Einträge des
         execute (y/x);                                                         // Stacks (y / x), entfernt die Einträge vom
                                                                                // Stack und speichert das Ergebnis auf dem Stack.
    }
}                                                                               // Ende Methode "Rechenoperation"
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     
public void Befehlsoperationen (String in)                                      // Beginn Methode "Befehlsoperationen"
{
    if(in.compareTo("neg") == 0)                                                // Übereinstimmung des Operator "neg" auf Gleichheit
    {                                      
         x = x*-1;                                                              // Negiert den obersten Eintrag im Stack.
    }
    else if(in.compareTo("st") == 0)                                            // Übereinstimmung des Operator "st" auf Gleichheit
    {                                       
        mem = x;                                                                // Speichert (store) den obersten Eintrag
        execute(y);                                                                 // aus dem Stack in einem internen Speicher mem.
                                                                                // Der gespeicherte Eintrag wird vom Stack entfernt.
    }
    else if(in.compareTo("rcl") == 0)                                           // Übereinstimmung des Operator "rcl" auf Gleichheit
    {                                      
        double a = x;                                                           // Zwischenvariable für y
        x = mem;                                                                // Lädt den gespeicherten Eintrag auf den Stack.
        z = y;
        y = a;                                                               
    }
    else if(in.compareTo("clr") == 0)                                           // Übereinstimmung des Operator "clr" auf Gleichheit
    {                                      
        x = 0;                                                                  // Entfernt alle Einträge vom Stack.
        y = 0;
        z = 0;
    }
    else if(in.compareTo("drop") == 0)                                          // Übereinstimmung des Operator "drop" auf Gleichheit
    {                                      
        execute(y);                                                             // Entfernt den obersten Eintrag aus dem Stack.
    }
    else if(in.compareTo("swap") == 0)                                          // Übereinstimmung des Operator "swap" auf Gleichheit
    {                                     
        double b = y;                                                           // Vertauscht die oberen beiden Einträge des Stacks.
        double c = x;
        x = b;
        y = c;
    }
    else if(in.compareTo("dup") == 0)                                           // Übereinstimmung des Operator "dup" auf Gleichheit
    {                                      
        double d = x;                                                           // Entfernt den obersten Eintrag des Stacks
        double e = y;                                                           // und legt ihn anschließend unverändert
        x = d;                                                                  // zweimal auf den Stack.
        y = d;
        z = e;
    }
}                                                                               // Ende Methode "Befehlsoperationen"
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// 
public void println ()                                                          // Beginn Methode "println"
{
    System.out.println("Stack: ["+x+","+y+","+z+"]");                           // Ausgabe des Stackes-Inhaltes
}                                                                               // Ende Methode "println"
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////     
}                                                                               // Ende der "Stack-Classe"
[/Java]

[Java]
public class myScanner 
{
    public static Scanner sc = new Scanner(System.in);
 //   public int pos = 0;
  //  public 
    public String asd;
    //public StringTokenizer tok = new StringTokenizer(" ");

    public String next()
    {
        String in = sc.next();
     //   String arg2 = sc.nextLine();
     //   arg = in.length();

        StringTokenizer st = new StringTokenizer(in);
        while (st.hasMoreTokens()) 
        {
            asd = (st.nextToken());   
        }
    //     System.out.println(in);  
    return asd;
    }

    public boolean empty()
    {
      return true;
    }   
}
[/Java]


----------

