# RPN Taschenrechner - keine Lösung!!



## javabeginners18 (17. Jan 2018)

Hallo,
mein Gruppenpartner und ich finden keine Lösung. Wir sind
ziemliche Anfänger im Gebiet Java und müssen für ein Projekt
im Studium einen RPN-Taschenrechner programmieren, ohne GUI.

Nun sind wir soweit, dass der Taschenrechner halbwegs funktioniert,
jedoch gibt es ein Problem:

Wir haben das Programm so geschrieben, dass der Stack mit .size()==1
angezeigt wird, da das Ergebnis eine Stackgröße von 1 haben soll.

Wenn man zum Beispiel 3 2 + eingibt funktioniert alles reibungslos,
jedoch wird es bei 3 3 * 4 4 * + Wurzel etwas schwerer, da das Programm
mehr als ein Ergebnis ausgibt.

Wir danken schonmal für jede Hilfe.


Hier der Code:


```
import java.util.Scanner;
import java.util.Stack;
import java.lang.Math;



public class UPNRechner {


    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //Benutzereingabe
        boolean verlassen = false;             //boolean zum Verlassen der while-Schleife bei true
        Stack<Double> ergebnis = new Stack();  //Stack erstellt

        int laengeVomStack = ergebnis.size();
        int i = 0;
        willkommen();
        eingabe();
        while (verlassen != true) {
            i++;
            String nutzereingabe;
            String antwortJN = "";

            nutzereingabe = scan.next();

            double zahl;
            try{
                zahl = Double.parseDouble(nutzereingabe);
            }catch(NumberFormatException e){
                     if(nutzereingabe.equals("+")   ||
                        nutzereingabe.equals("-")   ||
                        nutzereingabe.equals("*")   ||
                        nutzereingabe.equals("x")   ||
                        nutzereingabe.equals("/")   ||
                        nutzereingabe.equals("pow") ||
                        nutzereingabe.equals("cos") ||
                        nutzereingabe.equals("sqrt")||
                        nutzereingabe.equals("sin") ||
                        nutzereingabe.equals("cos") ||
                        nutzereingabe.equals("ln") ||
                        nutzereingabe.equals("~")   ||
                        nutzereingabe.equals("tan") ||
                        nutzereingabe.equals("euler") ||
                        nutzereingabe.equals("exit")){
                }
                   else {
                         System.out.println("Ungültige Eingabe! Bitte erneut versuchen:");
                         eingabe();
                         nutzereingabe = scan.next();
                     }
                    }

                    // Rechenoperatoren
            if(nutzereingabe.equals("+")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(ergebnis.pop() + ergebnisTmp);
            }else if (nutzereingabe.equals("-")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(ergebnis.pop() - ergebnisTmp);
            }else if (nutzereingabe.equals("x") || nutzereingabe.equals("*")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(ergebnis.pop() * ergebnisTmp);
            }else if (nutzereingabe.equals("/")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(ergebnis.pop() / ergebnisTmp);
            }else if (nutzereingabe.equals("sqrt")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(Math.sqrt(ergebnisTmp));
            }else if (nutzereingabe.equals("sin")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(Math.sin(ergebnisTmp));
            }else if (nutzereingabe.equals("cos")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(Math.cos(ergebnisTmp));
                ergebnis.push(Math.sin(ergebnisTmp));
            }else if (nutzereingabe.equals("~")){           

                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push((ergebnisTmp * (-1)));
            }else if (nutzereingabe.equals("tan")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(Math.tan(ergebnisTmp));
            }else if (nutzereingabe.equals("ln")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(Math.log(ergebnisTmp));
            }else if (nutzereingabe.equals("exp")){
                Double ergebnisTmp = ergebnis.pop();
                ergebnis.push(Math.pow(2.71828182846, 1));
            }else if (nutzereingabe.equals("pow")){
                Double ergebnisTmp = ergebnis.pop();
                System.out.println("Geben Sie einen Exponenten ein:");
                ergebnis.push(Math.pow(ergebnisTmp, scan.nextDouble()));

            }else if (nutzereingabe.equalsIgnoreCase("exit")){
                verlassen = true;
                if(verlassen == true) System.exit(0);
            } else ergebnis.push
                    (Double.parseDouble(nutzereingabe));

            if (i >=2  && ergebnis.size() == 1) {
                double finErgebnis = ergebnis.peek();
                System.out.println("  Ergebnis: " + finErgebnis);
                     }
                 }
            }

    public static void eingabe(){
        System.out.println("  ***Eingabe***");
        System.out.print("    ");

    }
    public static void willkommen() {
        System.out.println("                 ");
        System.out.println("*****************");
        System.out.println("Willkommen im " +
                "RPN-\n Taschenrechner!");
    }
}
```


----------



## JStein52 (17. Jan 2018)

was wird in dem obigen Beispiel ausgegeben ?


----------



## javabeginners18 (17. Jan 2018)

Also wenn man etwas simples eingibt, gibt es z. B. das hier aus:

******************
Willkommen im RPN-
 Taschenrechner!
  ***Eingabe***
3 3 +
  Ergebnis: 6.0
*
Wenn man dann so etwas eingibt, was mehrere .size()==1-Stacks hat, kommt das raus:

******************
Willkommen im RPN-
 Taschenrechner!
  ***Eingabe***
3 3 * 4 4 * + 
  Ergebnis: 9.0
  Ergebnis: 25.0*


----------



## JStein52 (17. Jan 2018)

Und das "Ergebnis: 9.0" soll weg ??? Oder "Ergebnis: 16" dazu ???


----------



## Meniskusschaden (17. Jan 2018)

Ändere das Programm doch so, dass es erst dann etwas ausgibt, wenn die Eingabe vollständig verarbeitet wurde. Dann kannst du dir noch überlegen, ob du nur das oberste Stapelelement oder den gesamten Stapel anzeigst (ich würde letzteres bevorzugen).


----------



## javabeginners18 (17. Jan 2018)

Ja, genau - das Ergebnis ganz unten soll immer alleine stehen. 
Das heißt in dem Beispiel die 25 soll als Endergebnis dastehen.


----------



## javabeginners18 (17. Jan 2018)

@Meniskusschaden Das ist halt etwas schwer umzusetzen für uns - gibt es da möglicherweise simple Ansätze dafür, das so zu machen, damit wir das richtige Ergebnis angezeigt bekommen?


----------



## javabeginners18 (17. Jan 2018)

???


----------



## mrBrown (17. Jan 2018)

javabeginners18 hat gesagt.:


> @Meniskusschaden Das ist halt etwas schwer umzusetzen für uns - gibt es da möglicherweise simple Ansätze dafür, das so zu machen, damit wir das richtige Ergebnis angezeigt bekommen?


Ihr müsst das Ende einer Rechnung erkennen - wenn eine Rechnung immer genau eine Zeile ist, bietet sich dafür Zeilenweises Einlesen an, und erst danach das splitten in einzelne Token.


----------



## javabeginners18 (18. Jan 2018)

Das Problem ist, dass wir das Projekt morgen abgeben müssen und keine Ahnung haben, wie wir das umsetzen bzw. anders machen können. Gibt es keine Möglichkeit, das so zu machen, wie wir das vorhaben? Denn die Funktionalität des Taschenrechners ist da, nur wir wollen nicht, dass Zwischenergebnisse angezeigt werden, wie es @JStein52 beschrieben hat. Wir wären für jede Hilfe dankbar.


----------



## Meniskusschaden (18. Jan 2018)

javabeginners18 hat gesagt.:


> Das Problem ist, dass wir das Projekt morgen abgeben müssen und keine Ahnung haben, wie wir das umsetzen bzw. anders machen können.


Aber hier steht doch schon, wie man das machen kann. Man ist fertig, sobald alle Token verarbeitet wurden. Dann gibt man das Ergebnis aus. Welche Schwierigkeiten gibt es denn dabei?


javabeginners18 hat gesagt.:


> Gibt es keine Möglichkeit, das so zu machen, wie wir das vorhaben?


Euer Ansatz mit Stackgröße 1 wird nicht funktionieren. Erstens kann Stackgröße 1 auch bei Zwischenergebnissen vorkommen und zweitens ist nicht gesagt, dass die Stackgrösse überhaupt 1 beträgt, wenn man fertig ist.


----------



## javabeginners18 (18. Jan 2018)

Können Sie uns möglicherweise etwas damit helfen? Das mit den Token bekommen wir echt nicht hin - seit Tagen nicht  Wir hatten das einfach so vor, dass das "letzte Element" des Stacks, welches die Stackgröße 1 hat, eingeblendet wird. Kann man das Programm leicht umschreiben bis morgen? Wir wissen wirklich nicht wie, können Sie uns helfen? Wir müssten die volle Punktzahl bekommen, um zu bestehen


----------



## Meniskusschaden (18. Jan 2018)

javabeginners18 hat gesagt.:


> Das mit den Token bekommen wir echt nicht hin


Ihr zerlegt die Eingabe doch bereits in Token. Jeder Aufruf von `scan.next()` liefert ein neues Token. Die Schwierigkeit liegt darin, zu erkennen, wann kein Token mehr kommt, denn wenn ihr von der Konsole einlest, blockiert `scan.next()` so lange, bis wieder etwas eingegeben wird.
Ihr könnt es aber so machen, wie @mrBrown es vorgeschlagen hat, z.B. indem ihr mit einem Scanner eine vollständige Zeile von der Konsole in einen String einlest und mit einem zweiten Scanner diesen String in Token zerlegt. Wenn man von einem String einliest, blockiert der Scanner am String-Ende nämlich nicht. Der Scanner liefert alle Methoden, die man dafür benötigt. Ggf. müsst ihr da mal in die Doku schauen.


----------



## javabeginners18 (18. Jan 2018)

Wir sind wirklich *Anfänger* im Gebiet Java, ich möchte keinem zur Last fallen, aber kann jemand möglicherweise einen Ansatz bzw. das mit den zwei Scannern erklären, wir brauchen eben nur eine kleine Erklärung und/oder ein Codebeispiel dazu, weil das Verstehen in diesem Gebiet fällt uns noch recht schwer. 
Am Besten wäre es für uns, da wir Anfänger sind und sogar für diesen Code einige Tage gebraucht haben, dass wir mit unserem jetzigen Code etwas anfangen können und diesen nur etwas umändern müssen, statt das ganze Projekt zu zerlegen.  Danke und sorry


----------



## Flown (18. Jan 2018)

```
import java.util.Scanner;

public class Test {
  public static void main(String... args) {
    Scanner scanner = new Scanner(System.in);
    while(scanner.hasNextLine()) {
      Scanner tokenizer = new Scanner(scanner.nextLine());
      for(int i = 0; tokenizer.hasNext(); i++) {
        System.out.printf("%d: %s%n", i, tokenizer.next());
      }
    }
  }
}
```
Hier...


----------



## javabeginners18 (18. Jan 2018)

Das ist wirklich sehr lieb von euch, sehr hilfreich  sind so happy  
Muss ich dafür aber auch etwas entfernen bzw. welchen Teil müssen wir entfernen?


----------



## Meniskusschaden (18. Jan 2018)

javabeginners18 hat gesagt.:


> Muss ich dafür aber auch etwas entfernen bzw. welchen Teil müssen wir entfernen?


Wow, das waren fast fünf Minuten! So viel Zeit habt ihr euch genommen, um selbst zu versuchen, das auf euer Programm zu übertragen. Mehr kann man für volle Punktzahl wirklich nicht erwarten.


----------



## javabeginners18 (18. Jan 2018)

Wir fragen das, damit wir das auch richtig hinbekommen, da wir sehr wenig Erfahrung und Wissen darüber haben.


----------



## JStein52 (18. Jan 2018)

Hier mal auf die Schnelle euer Programm umgebaut:

```
import java.util.Scanner;
import java.util.Stack;
import java.lang.Math;

public class UPNRechner {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //Benutzereingabe
        boolean verlassen = false;             //boolean zum Verlassen der while-Schleife bei true
        Stack<Double> ergebnis = new Stack();  //Stack erstellt
        int laengeVomStack = ergebnis.size();
        int i = 0;
        willkommen();
        eingabe();

        Scanner scanner = new Scanner(System.in);
        while (true) {
            String nextLine = scanner.nextLine();
            Scanner tokenizer = new Scanner(nextLine);
            i = 0;
            ergebnis.clear();
            for (int ii = 0; tokenizer.hasNext(); ii++) {
                i++;
                String nutzereingabe;
                String antwortJN = "";
                nutzereingabe = tokenizer.next();
                double zahl;
                try {
                    zahl = Double.parseDouble(nutzereingabe);
                } catch (NumberFormatException e) {
                    if (nutzereingabe.equals("+")
                            || nutzereingabe.equals("-")
                            || nutzereingabe.equals("*")
                            || nutzereingabe.equals("x")
                            || nutzereingabe.equals("/")
                            || nutzereingabe.equals("pow")
                            || nutzereingabe.equals("cos")
                            || nutzereingabe.equals("sqrt")
                            || nutzereingabe.equals("sin")
                            || nutzereingabe.equals("cos")
                            || nutzereingabe.equals("ln")
                            || nutzereingabe.equals("~")
                            || nutzereingabe.equals("tan")
                            || nutzereingabe.equals("euler")
                            || nutzereingabe.equals("exit")) {
                    } else {
                        System.out.println("Ungültige Eingabe! Bitte erneut versuchen:");
                        break;
                    }
                }

                // Rechenoperatoren
                if (nutzereingabe.equals("+")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(ergebnis.pop() + ergebnisTmp);
                } else if (nutzereingabe.equals("-")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(ergebnis.pop() - ergebnisTmp);
                } else if (nutzereingabe.equals("x") || nutzereingabe.equals("*")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(ergebnis.pop() * ergebnisTmp);
                } else if (nutzereingabe.equals("/")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(ergebnis.pop() / ergebnisTmp);
                } else if (nutzereingabe.equals("sqrt")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.sqrt(ergebnisTmp));
                } else if (nutzereingabe.equals("sin")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.sin(ergebnisTmp));
                } else if (nutzereingabe.equals("cos")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.cos(ergebnisTmp));
                    ergebnis.push(Math.sin(ergebnisTmp));
                } else if (nutzereingabe.equals("~")) {

                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push((ergebnisTmp * (-1)));
                } else if (nutzereingabe.equals("tan")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.tan(ergebnisTmp));
                } else if (nutzereingabe.equals("ln")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.log(ergebnisTmp));
                } else if (nutzereingabe.equals("exp")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.pow(2.71828182846, 1));
                } else if (nutzereingabe.equals("pow")) {
                    Double ergebnisTmp = ergebnis.pop();
                    System.out.println("Geben Sie einen Exponenten ein:");
                    ergebnis.push(Math.pow(ergebnisTmp, scan.nextDouble()));

                } else if (nutzereingabe.equalsIgnoreCase("exit")) {
                        System.exit(0);
                } else {
                    ergebnis.push(Double.parseDouble(nutzereingabe));
                }

            }
            if (i >= 2 && ergebnis.size() == 1) {
                double finErgebnis = ergebnis.peek();
                System.out.println("  Ergebnis: " + finErgebnis);
            }
        }
    }

    public static void eingabe() {
        System.out.println("  ***Eingabe***");
        System.out.print("    ");

    }

    public static void willkommen() {
        System.out.println("                 ");
        System.out.println("*****************");
        System.out.println("Willkommen im "
                + "RPN-\n Taschenrechner!");
    }
}
```


----------



## javabeginners18 (18. Jan 2018)

Wow, vielen vielen Dank, genau so hab ich das gemeint, umsetzen zu wollen  Das hat uns echt nochmal gerettet, Dankeschön. 
Ich weiß nicht, ob ich schon langsam nerve, ich befürchte ja, aber ich hätte noch einige kleine Fragen, wenn es keine Umstände für Sie wäre: 
Wenn ich zum Beispiel das Wort "pi" als Benutzer eingebe, wie können wir das programmieren, dass 
eine Zahl pi zum Stack hinzugefügt wird, da man ja pi mal, plus, minus und mal nehmen kann.. ich hoffe diese Frage war verständlich :/


----------



## JStein52 (18. Jan 2018)

Analog zu den anderen Operatoren. Ihr kriegt für pi beim parseDouble eine Exception, d h. ihr fügt im catch einen Zweig für pi ein. Dann braucht ihr in dem Zweig wo die ganzen Operatoren verarbeitet werden einen Zweig in dem ihr auf pi abfragt und falls ja Math.PI auf den Stack pusht


----------



## JStein52 (18. Jan 2018)

Ergibt dann so was:

*****************
Willkommen im RPN-
 Taschenrechner!
  ***Eingabe***
    pi 2 *
  Ergebnis: 6.283185307179586

Und da:

```
} else if (nutzereingabe.equals("cos")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.cos(ergebnisTmp));
                    ergebnis.push(Math.sin(ergebnisTmp));
```
 ist wohl eine Zeile zuviel reingerutscht


----------



## JStein52 (18. Jan 2018)

Hier ist auch noch ein Fehlerlein:

```
} else if (nutzereingabe.equals("exp")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.pow(2.71828182846, 1));
```
sollte wohl

```
} else if (nutzereingabe.equals("exp")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.pow(2.71828182846, ergebnisTmp));
```
 heissen. Darüberhinaus fragt ihr oben im catch auf "euler" ab und hier aber auf "exp"

Edit: und statt 2.718......   besser Math.E benutzen


----------



## javabeginners18 (18. Jan 2018)

Wow, besser als mein Prof  Kann man eigentlich einbauen, dass wenn der User z. B. die Taste "R" drückt, dass sich dieser Rechner "reloaden" soll, oder einfach von neu beginnen soll?


----------



## JStein52 (18. Jan 2018)

Hier noch zur Kontrolle die pi-Geschichte:

```
|| nutzereingabe.equals("tan")
                            || nutzereingabe.equals("pi")
                            || nutzereingabe.equals("exp")
```
und 
	
	
	
	





```
} else if (nutzereingabe.equals("exp")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.pow(Math.E, ergebnisTmp));
                } else if (nutzereingabe.equals("pi")) {
                    ergebnis.push(Math.PI);
```



javabeginners18 hat gesagt.:


> Kann man eigentlich einbauen, dass wenn der User z. B. die Taste "R" drückt, dass sich dieser Rechner "reloaden" soll, oder einfach von neu beginnen soll?


Du meinst wenn man eine halbe Zeile hingeschrieben hat und jetzt möchte man einfach neu anfangen ?


----------



## javabeginners18 (18. Jan 2018)

Ich habe das mal probiert, da kommt jedoch eine Exception, habe das auch beim catch eingefügt:

```
...
} else if (nutzereingabe.equals("pi")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.PI);
```


----------



## javabeginners18 (18. Jan 2018)

Also, ich meine entweder im Fall, dass das Ergebnis angezeigt wird, wie auch mittendrin - 
dass man einfach den Rechner so oft benutzen kann wie man will, ohne immer auf "Play" gehen zu müssen.

Edit: Ah Ok, da muss einfach das Double ergebnisTmp beim PI wegfallen  Danke


----------



## javabeginners18 (18. Jan 2018)

noch wegen dem Euler und Exp... wir haben zwei Sachen einzubauen:

wir müssen das e an sich einbauen, also das Math.E..
und wir müssen das _exp *Exponential to base e* _einbauen, 
also quasi e hoch irgendwas, was der User eingibt. 

Kann man das auch über einen internen Befehl,
der schon abgespeichert ist, wie z. B. Math.E einfügen,
oder muss das selbst gemacht werden?


----------



## JStein52 (18. Jan 2018)

javabeginners18 hat gesagt.:


> noch wegen dem Euler und Exp... wir haben zwei Sachen einzubauen:


Kannst du mal ein Beispiel angeben dazu ? Was soll eingegeben werden ?

Und im Fall dass ein Ergebnis angezeigt wird kannst du doch einfach eine neue Rechnung eingeben, das funktioniert doch schon ...


----------



## javabeginners18 (18. Jan 2018)

Oh stimmt, das habe ich gar nicht bemerkt  
also das *e* an sich muss eingebaut werden, Beispiel: 5 e * 
dazu kommt einfach noch das *exp*, das ist einfach e hoch die Zahl, die der Benutzer eingibt, Beispiel:
exp 2 (ist in dem Fall e hoch 2)
So wollen die das denke ich haben..


----------



## JStein52 (18. Jan 2018)

Ja gut. Also exp ist dann schon genau so drin wie du möchtest und das mit dem e baust du haargenau so an den zwei stellen ein wo jetzt die Geschichte mit pi eingebaut ist.


----------



## JStein52 (18. Jan 2018)

Kleinigkeit noch: du meinst 2 exp  und nicht exp 2


----------



## javabeginners18 (18. Jan 2018)

Genau, das habe ich hinbekommen  Haben Sie noch Zeit/Lust mir bei Kleinigkeiten zu helfen, die ich auch nicht hinbekommen habe? Es ist echt gut, jemanden zu haben, der sich etwas besser mit dem Stoff auskennt.


----------



## JStein52 (18. Jan 2018)

Ihr solltet übrigens den ganzen Block mit der Verarbeitung der Operationen auch noch mit try/catch absichern weil ihr da z.B. eine EmptyStackException kriegen könnt wenn ihr exp 2 eingebt. So:

```
try {
                    // Rechenoperatoren
                    if (nutzereingabe.equals("+")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() + ergebnisTmp);
                    } else if (nutzereingabe.equals("-")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() - ergebnisTmp);
                    } else if (nutzereingabe.equals("x") || nutzereingabe.equals("*")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() * ergebnisTmp);
                    } else if (nutzereingabe.equals("/")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() / ergebnisTmp);
                    } else if (nutzereingabe.equals("sqrt")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.sqrt(ergebnisTmp));
                    } else if (nutzereingabe.equals("sin")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.sin(ergebnisTmp));
                    } else if (nutzereingabe.equals("cos")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.cos(ergebnisTmp));
                    } else if (nutzereingabe.equals("~")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push((ergebnisTmp * (-1)));
                    } else if (nutzereingabe.equals("tan")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.tan(ergebnisTmp));
                    } else if (nutzereingabe.equals("ln")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.log(ergebnisTmp));
                    } else if (nutzereingabe.equals("exp")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.pow(Math.E, ergebnisTmp));
                    } else if (nutzereingabe.equals("pi")) {
                        ergebnis.push(Math.PI);
                    } else if (nutzereingabe.equals("e")) {
                        ergebnis.push(Math.E);
                    } else if (nutzereingabe.equals("pow")) {
                        Double ergebnisTmp = ergebnis.pop();
                        System.out.println("Geben Sie einen Exponenten ein:");
                        ergebnis.push(Math.pow(ergebnisTmp, scan.nextDouble()));

                    } else if (nutzereingabe.equalsIgnoreCase("exit")) {
                        System.exit(0);
                    } else {
                        ergebnis.push(Double.parseDouble(nutzereingabe));
                    }
                } catch (Exception e) {
                    System.out.println("Ungültige Eingabe! Bitte erneut versuchen:");
                    break;
                }
```


----------



## JStein52 (18. Jan 2018)

javabeginners18 hat gesagt.:


> Haben Sie noch Zeit/Lust mir bei Kleinigkeiten zu helfen, die ich auch nicht hinbekommen habe


Ja, um was geht's denn


----------



## javabeginners18 (18. Jan 2018)

Wow, hier kann man sogar richtig gut dazulernen  macht echt Spaß 
Eigentlich war das genau einer meiner Fragen, wie ich es verhindere eine Fehlermeldung seitens der Software bekomme  z. B. wenn ich 3 3 eingebe und Enter drücke soll auch eine kleine Anzeige kommen wie "Vervollständigen Sie die Zeile" oder so etwas


----------



## javabeginners18 (18. Jan 2018)

JStein52 hat gesagt.:


> Ja, um was geht's denn


Also es geht um folgendes: Ich hab den Code so geändert, dass in der Konsole unten der Taschenrechner etwas "schöner" wirkt, hab es leicht mittig gemacht - nur nach dem ich etwas falsches eingebe, ist die Usereingabe leicht verschoben. 

Am Besten sende ich den Code mal, ich will einfach, dass die Usereingabe nach dem man was falsch eingibt, an der selben Position ist, wie am Anfang.


```
import java.util.Scanner;
import java.util.Stack;

public class UPNRechner {


        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in); //Benutzereingabe
            boolean verlassen = false;             //boolean zum Verlassen der while-Schleife bei true
            Stack<Double> ergebnis = new Stack();  //Stack erstellt
            int laengeVomStack = ergebnis.size();
            int i = 0;
            willkommen();    //Willkommenstext
            eingabe();      //
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.print("  ");
                String nextLine = scanner.nextLine();
                Scanner tokenizer = new Scanner(nextLine);
                i = 0;
                ergebnis.clear();
                for (int ii = 0; tokenizer.hasNext(); ii++) {
                    i++;
                    String nutzereingabe;
                    nutzereingabe = tokenizer.next();
                    double zahl;
                    try {
                        zahl = Double.parseDouble(nutzereingabe);
                    } catch (NumberFormatException e) {
                               if (nutzereingabe.equals("+")
                                || nutzereingabe.equals("-")
                                || nutzereingabe.equals("*")
                                || nutzereingabe.equals("x")
                                || nutzereingabe.equals("/")
                                || nutzereingabe.equals(":")
                                || nutzereingabe.equals("pow")
                                || nutzereingabe.equals("cos")
                                || nutzereingabe.equals("sqrt")
                                || nutzereingabe.equals("sin")
                                || nutzereingabe.equals("cos")
                                || nutzereingabe.equals("ln")
                                || nutzereingabe.equals("~")
                                || nutzereingabe.equals("e")
                                || nutzereingabe.equals("tan")
                                || nutzereingabe.equals("exp")
                                || nutzereingabe.equals("pi")
                                || nutzereingabe.equals("exit")) {
                        } else {
                            System.out.println("       Ungültige Eingabe! \n" +
                                    "          Bitte erneut \n           versuchen:");
                            break;
                        }
                    }
                    try {
                        // Rechenoperatoren
                        if (nutzereingabe.equals("+")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(ergebnis.pop() + ergebnisTmp);
                        } else if (nutzereingabe.equals("-")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(ergebnis.pop() - ergebnisTmp);
                        } else if (nutzereingabe.equals("x") ||
                                nutzereingabe.equals("*")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(ergebnis.pop() * ergebnisTmp);
                        } else if (nutzereingabe.equals("/") ||
                                (nutzereingabe.equals(":"))) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(ergebnis.pop() / ergebnisTmp);
                        } else if (nutzereingabe.equals("sqrt")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.sqrt(ergebnisTmp));
                        } else if (nutzereingabe.equals("sin")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.sin(ergebnisTmp));
                        } else if (nutzereingabe.equals("cos")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.cos(ergebnisTmp));
                        } else if (nutzereingabe.equals("tan")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.tan(ergebnisTmp));
                        } else if (nutzereingabe.equals("~")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push((ergebnisTmp * (-1)));
                        } else if (nutzereingabe.equals("ln")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.log(ergebnisTmp));
                        } else if (nutzereingabe.equals("exp")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.pow(Math.E, ergebnisTmp));
                        } else if (nutzereingabe.equals("pi")) {
                            ergebnis.push(Math.PI);
                        } else if (nutzereingabe.equals("pow")) {
                            Double ergebnisTmp = ergebnis.pop();
                            System.out.println("         Geben Sie einen " +
                                             "\n         Exponenten ein:");
                            System.out.print("      ");
                            ergebnis.push(Math.pow(ergebnisTmp, scan.nextDouble()));
                        } else if (nutzereingabe.equals("e")) {
                            ergebnis.push(Math.E);
                        } else if (nutzereingabe.equalsIgnoreCase("exit")) {
                            System.exit(0);
                        } else {
                            ergebnis.push(Double.parseDouble(nutzereingabe));
                        }
                    }  catch (Exception e) {
                    System.out.println("      Ungültige Eingabe! \n" +
                            "     Bitte erneut versuchen:");
                    break;
                }
                }
                if (i >= 2 && ergebnis.size() == 1) {
                    double finErgebnis = ergebnis.peek();
                    System.out.println("            Ergebnis: ");
                    System.out.println("            " + finErgebnis);
                }
            }
        }
        public static void eingabe() {
            System.out.println("            Eingabe:    ");
            System.out.print("    ");

        }
        public static void willkommen() {
            System.out.println("      U P N-TASCHENRECHNER");
            System.out.println("      ********************");
        }
}
```


----------



## javabeginners18 (18. Jan 2018)

und ich müsste nur noch das hier machen:

2, 3.0, -1.82 1.3E-23   IEEE 754 Double-precision 
_________________________________________
0b100, -0B101            Integer Binary representation
_________________________________________
0xa7, -0xB2FF             Integer Hexadecimal representation


Man soll die Sachen auf der linken Seite eingeben können (denk ich) damit aus Binär und Hexadezimalzahl normale Dezimalzahlen werden  Gibt es dafür auch ein vorprogrammierten Befehl in Java?


----------



## JStein52 (18. Jan 2018)

javabeginners18 hat gesagt.:


> nur nach dem ich etwas falsches eingebe, ist die Usereingabe leicht verschoben.



meinst du die Sache dass bei wiederholten Eingaben die Eingaben linksbündig stattfinden, deine Ausgaben aber nach rechts gerückt ? die Eingabe soll dann auch weiter rechts stattfinden ?


----------



## javabeginners18 (18. Jan 2018)

JStein52 hat gesagt.:


> meinst du die Sache dass bei wiederholten Eingaben die Eingaben linksbündig stattfinden, deine Ausgaben aber nach rechts gerückt ? die Eingabe soll dann auch weiter rechts stattfinden ?



Genau


----------



## JStein52 (18. Jan 2018)

Also das hier geht eh schon, ohne dass du noch was machen musst:
run:
      U P N-TASCHENRECHNER
      ********************

            Eingabe:   
        1.0 2.1 +
            Ergebnis:
            3.1

            Eingabe:   
        1.2e-2 3 +
            Ergebnis:
            3.012

            Eingabe:


----------



## JStein52 (18. Jan 2018)

Und wenn du eingabe() an dieser Stelle aufrufst kommt es dem wie du es willst schon näher:

```
int i = 0;
            willkommen();    //Willkommenstext
            Scanner scanner = new Scanner(System.in);
            while (true) {
                eingabe();      //
                String nextLine = scanner.nextLine();
                Scanner tokenizer = new Scanner(nextLine);
                i = 0;
```
 du kannst jetzt in der "eingabe()" durch geeignete Blanks etc. steuern wo die Eingabe stattfindet


----------



## javabeginners18 (18. Jan 2018)

Ok, das hat geklappt  danke dafür.. 
wie ist es mit dem Binär und Hexa? das hab ich gegoogelt, aber 
ich finde nur heraus, dass man doubles in hexa umwandeln kann, aber
andersherum nicht  
..und einer der letzten Fragen: 
Kann ich zum Beispiel diesen if-else-Dschungel sauber darstellen? Geht das überhaupt in der Form mit einem switch-case?


----------



## JStein52 (18. Jan 2018)

javabeginners18 hat gesagt.:


> 0b100, -0B101 Integer Binary representation
> _________________________________________
> 0xa7, -0xB2FF Integer Hexadecimal representation



Es gibt hierzu die Methode Integer.parseInt("0f0F", 16) bzw. Integer.parseInt("100101", 2); mit denen du
Hex-Zahlen bzw. Binärzahlen nach Integer umwandeln kannst.  Dazu müsstest du dann nach dem tokenizer aber erst mal abprüfen beginnt der String mit 0x oder 0X bzw. -0x -0X  und dann die 16er-Variante aufrufen und das selbe mit 0b0B bzw. -0b -0B und dann die 2er Variante aufrufen


----------



## JStein52 (18. Jan 2018)

javabeginners18 hat gesagt.:


> Kann ich zum Beispiel diesen if-else-Dschungel sauber darstellen


Würde ich so lassen denn swith case gibt den gleichen Dschungel nur mit anderen Schlüsselworten.


----------



## javabeginners18 (18. Jan 2018)

JStein52 hat gesagt.:


> Dazu müsstest du dann nach dem tokenizer aber erst mal abprüfen beginnt der String mit 0x oder 0X bzw. -0x -0X  und dann die 16er-Variante aufrufen und das selbe mit 0b0B bzw. -0b -0B und dann die 2er Variante aufrufen



muss ich hier dann eine for-Schleife machen? oder einfach _*if(nutzereingabe.substring(0,2).equals("0x")........
*_


----------



## JStein52 (18. Jan 2018)

```
nutzereingabe = tokenizer.next();
                    double zahl;
                    try {
                        if (nutzereingabe.startsWith("0x") || nutzereingabe.startsWith("0X"))
                            zahl = Integer.parseInt(nutzereingabe.substring(2), 16);
                        else if (nutzereingabe.startsWith("-0x") || nutzereingabe.startsWith("-0X"))
                            zahl = Integer.parseInt(nutzereingabe.substring(3), 16);
                        else if //  .... analog fuer 0b 0B, -0b -0B
                        ..
                        else zahl = Double.parseDouble(nutzereingabe);
                    } catch (NumberFormatException e) {
```
 so etwa


----------



## javabeginners18 (18. Jan 2018)

Wenn ich aber nun z. B. 0xa7 eingebe, steht hier ungültige Eingabe,
am Besten schicke ich hier nochmal meinen Code ein:  
Danke bis jetzt für jede Hilfe, Sie waren mir eine sehr sehr große
Hilfe 


```
import java.util.Scanner;
import java.util.Stack;

public class UPNRechner {

    public static void main(String[] args) {

            Scanner scan = new Scanner(System.in); //Benutzereingabe
            boolean verlassen = false;             //boolean zum Verlassen der while-Schleife bei true
            Stack<Double> ergebnis = new Stack();  //Stack erstellt
            int i = 0;
            willkommen();    //Überschrift
            Scanner scanner = new Scanner(System.in);


            /*
            while-Schleife, welche den Großteil des Taschenrechners beinhaltet
             */
            while (true) {
                eingabefeld(); // Text und "Effekte"
                System.out.print("  ");
                String nextLine = scanner.nextLine();
                Scanner tokenizer = new Scanner(nextLine);
                i = 0;
                ergebnis.clear();
                for (int ii = 0; tokenizer.hasNext(); ii++) {
                    i++;
                    String nutzereingabe;
                    nutzereingabe = tokenizer.next();

                    double zahl;
                    try {
                        if (nutzereingabe.startsWith("0x") || nutzereingabe.startsWith("0X"))
                            zahl = Integer.parseInt(nutzereingabe.substring(2), 16);
                        else if (nutzereingabe.startsWith("-0x") || nutzereingabe.startsWith("-0X"))
                            zahl = Integer.parseInt(nutzereingabe.substring(3), 16);
                        else if (nutzereingabe.startsWith("0b") || nutzereingabe.startsWith("0B"))
                            zahl = Integer.parseInt(nutzereingabe.substring(2), 2);
                        else if (nutzereingabe.startsWith("-0b") || nutzereingabe.startsWith("-0B"))
                            zahl = Integer.parseInt(nutzereingabe.substring(3), 2);
                        else zahl = Double.parseDouble(nutzereingabe);
                    } catch (NumberFormatException e) {
                               if (nutzereingabe.equals("+")
                                || nutzereingabe.equals("-")
                                || nutzereingabe.equals("*")
                                || nutzereingabe.equals("x")
                                || nutzereingabe.equals("/")
                                || nutzereingabe.equals(":")
                                || nutzereingabe.equals("÷")
                                || nutzereingabe.equals("pow")
                                || nutzereingabe.equals("cos")
                                || nutzereingabe.equals("sqrt")
                                || nutzereingabe.equals("√")
                                || nutzereingabe.equals("sin")
                                || nutzereingabe.equals("cos")
                                || nutzereingabe.equals("ln")
                                || nutzereingabe.equals("~")
                                || nutzereingabe.equals("e")
                                || nutzereingabe.equals("tan")
                                || nutzereingabe.equals("exp")
                                || nutzereingabe.equals("pi")
                                || nutzereingabe.equals("exit")) {
                        } else {
                            ungueltigeEingabe();
                            break;
                        }
                    }
                    /*
                    *
                    In der folgenden try-catch-Anweisung sind die Funk-
                    tionen der Rechenoperatoren angegeben - ebenso wird
                    hier geprüft, ob die Eingabe des Benutzers richtig
                    ist und/oder der Reihenfolge entspricht, in der diese
                    sein soll. Falls sich die Eingabe nicht um den Typ
                    Double oder um einen definierten Rechenoperatoren, etc.
                    handelt, soll für den Benutzer eine Fehlermeldung
                    erscheinen, die den Nutzer dazu auffordert, die
                    Handlung in korrekter Weise zu wiederholen.
                    *
                    */
                    try {
                        if (nutzereingabe.equals("+")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(ergebnis.pop() + ergebnisTmp);
                        } else if (nutzereingabe.equals("-")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(ergebnis.pop() - ergebnisTmp);
                        } else if (nutzereingabe.equals("x") ||
                                   nutzereingabe.equals("*")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(ergebnis.pop() * ergebnisTmp);
                        } else if (nutzereingabe.equals("/") ||
                                  (nutzereingabe.equals(":"))) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(ergebnis.pop() / ergebnisTmp);
                        } else if (nutzereingabe.equals("sqrt")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.sqrt(ergebnisTmp));
                        } else if (nutzereingabe.equals("sin")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.sin(ergebnisTmp));
                        } else if (nutzereingabe.equals("cos")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.cos(ergebnisTmp));
                        } else if (nutzereingabe.equals("tan")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.tan(ergebnisTmp));
                        } else if (nutzereingabe.equals("~")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push((ergebnisTmp * (-1)));
                        } else if (nutzereingabe.equals("ln")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.log(ergebnisTmp));
                        } else if (nutzereingabe.equals("exp")) {
                            Double ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.pow(Math.E, ergebnisTmp));
                        } else if (nutzereingabe.equals("pi")) {
                            ergebnis.push(Math.PI);
                        } else if (nutzereingabe.equals("pow")) {
                            Double ergebnisTmp = ergebnis.pop();
                            exponenteingeben();
                            ergebnis.push(Math.pow(ergebnisTmp, scan.nextDouble()));
                        } else if (nutzereingabe.equals("e")) {
                            ergebnis.push(Math.E);
                        } else if (nutzereingabe.equalsIgnoreCase("exit")) {
                            System.exit(0);
                        } else {
                            ergebnis.push(Double.parseDouble(nutzereingabe));
                        }
                    }catch (Exception e) {
                    ungueltigeEingabe();    // Text, ungueltigeEing
                    break;
                  }
                }
                if (i >= 2 && ergebnis.size() == 1) {
                    double finErgebnis = ergebnis.peek();
                    System.out.println("            Ergebnis: ");
                    System.out.println("               " + finErgebnis);
                    System.out.println("                       ");
                }
            }
        }
        public static void eingabefeld() {
            System.out.println("      ********************");
            System.out.println("            Eingabe:  ");
            System.out.print("    ");

        }
        public static void willkommen() {
              System.out.println("                          ");
            System.out.println("      U P N-TASCHENRECHNER");
        }
        public static void ungueltigeEingabe() {
            System.out.println("       Ungültige Eingabe! \n" +
                    "     Bitte erneut versuchen:");
        }
        public static void exponenteingeben() {
            System.out.println("         Geben Sie einen " +"\n" +
                    "         Exponenten ein:");
            System.out.print("      ");
    }
}
```


----------



## JStein52 (18. Jan 2018)

Du hast weiter unten nochmal ein Double.parseDouble drin gehabt, das muss ersatzlos raus. zahl enthält ja schon den richtigen Wert.

```
} else if (nutzereingabe.equalsIgnoreCase("exit")) {
                            System.exit(0);
                        } else {
                            ergebnis.push(zahl);
                        }
                    }  catch (Exception e) {
```
Er wird dir zunächst meckern dass Zahl nicht initialisiert ist. Das intialisierst du oben mit 0.0:

double zahl = 0.0;


----------



## javabeginners18 (18. Jan 2018)

Jetzt funktioniert es, jedoch wenn man eine Zahl eingibt und danach erst etwas falsches, gibt er das Ergebnis: x auch aus:

*Beispiel:*

Eingabe: *3 3 + wioejf top nowwefwf*
Ungültige Eingabe!
Bitte erneut versuchen:
_Ergebnis: 6.0_

******************
Eingabe:


----------



## JStein52 (18. Jan 2018)

ok,
suche nach break und mache folgendes:

```
i = 0;
                        break;
```
Achtung, kommt zweimal vor. Das verhindert die Ausgabe.


----------



## javabeginners18 (19. Jan 2018)

JStein52 hat gesagt.:


> ok,
> suche nach break und mache folgendes:
> 
> ```
> ...




Hi,
ich habe das so gemacht und bei beiden versucht, ein i=0; drüber zu setzen, habe es auch bei beiden und auch einzeln probiert, trotzdem gibt er mir das aus:

      U P N-TASCHENRECHNER
      ********************
      Eingabe:  3 3 + fwehjfwoijef
      Ungültige Eingabe.
      Bitte erneut versuchen!
_*Ergebnis: 6.0*_

      ********************
      Eingabe:


_EDIT: Das passiert nur wenn ich die 3 3 + am *Anfang* eingebe,
wenn ich zum Beispiel: *fheuwih pj 3 3 +* eingebe kommt nicht das unerwünschte "Ergebnis: 6" raus_


----------



## JStein52 (19. Jan 2018)

Mhmm bei mir funktioniert es:

```
import java.util.Scanner;
import java.util.Stack;

public class UPNRechner {

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in); //Benutzereingabe
        boolean verlassen = false;             //boolean zum Verlassen der while-Schleife bei true
        Stack<Double> ergebnis = new Stack();  //Stack erstellt
        int laengeVomStack = ergebnis.size();
        int i = 0;
        willkommen();    //Willkommenstext
        Scanner scanner = new Scanner(System.in);
        while (true) {
            eingabe();      //
            String nextLine = scanner.nextLine();
            Scanner tokenizer = new Scanner(nextLine);
            i = 0;
            ergebnis.clear();
            for (int ii = 0; tokenizer.hasNext(); ii++) {
                i++;
                String nutzereingabe;
                nutzereingabe = tokenizer.next();
                double zahl = 0.0;
                try {
                    if (nutzereingabe.startsWith("0x") || nutzereingabe.startsWith("0X")) {
                        zahl = Integer.parseUnsignedInt(nutzereingabe.substring(2), 16);
                    } else if (nutzereingabe.startsWith("-0x") || nutzereingabe.startsWith("-0X")) {
                        zahl = Integer.parseInt(nutzereingabe.substring(3), 16);
                    } else if (nutzereingabe.startsWith("0b") || nutzereingabe.startsWith("0B")) {
                        zahl = Integer.parseInt(nutzereingabe.substring(2), 2);
                    } else if (nutzereingabe.startsWith("-0b") || nutzereingabe.startsWith("-0B")) {
                        zahl = Integer.parseInt(nutzereingabe.substring(3), 2);
                    } else {
                        zahl = Double.parseDouble(nutzereingabe);
                    }
                } catch (NumberFormatException e) {
                    if (nutzereingabe.equals("+")
                            || nutzereingabe.equals("-")
                            || nutzereingabe.equals("*")
                            || nutzereingabe.equals("x")
                            || nutzereingabe.equals("/")
                            || nutzereingabe.equals(":")
                            || nutzereingabe.equals("pow")
                            || nutzereingabe.equals("cos")
                            || nutzereingabe.equals("sqrt")
                            || nutzereingabe.equals("sin")
                            || nutzereingabe.equals("cos")
                            || nutzereingabe.equals("ln")
                            || nutzereingabe.equals("~")
                            || nutzereingabe.equals("e")
                            || nutzereingabe.equals("tan")
                            || nutzereingabe.equals("exp")
                            || nutzereingabe.equals("pi")
                            || nutzereingabe.equals("exit")) {
                    } else {
                        System.out.println("       Ungültige Eingabe! \n"
                                + "          Bitte erneut \n           versuchen:");
                        i = 0;
                        break;
                    }
                }
                try {
                    // Rechenoperatoren
                    if (nutzereingabe.equals("+")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() + ergebnisTmp);
                    } else if (nutzereingabe.equals("-")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() - ergebnisTmp);
                    } else if (nutzereingabe.equals("x")
                            || nutzereingabe.equals("*")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() * ergebnisTmp);
                    } else if (nutzereingabe.equals("/")
                            || (nutzereingabe.equals(":"))) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() / ergebnisTmp);
                    } else if (nutzereingabe.equals("sqrt")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.sqrt(ergebnisTmp));
                    } else if (nutzereingabe.equals("sin")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.sin(ergebnisTmp));
                    } else if (nutzereingabe.equals("cos")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.cos(ergebnisTmp));
                    } else if (nutzereingabe.equals("tan")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.tan(ergebnisTmp));
                    } else if (nutzereingabe.equals("~")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push((ergebnisTmp * (-1)));
                    } else if (nutzereingabe.equals("ln")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.log(ergebnisTmp));
                    } else if (nutzereingabe.equals("exp")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.pow(Math.E, ergebnisTmp));
                    } else if (nutzereingabe.equals("pi")) {
                        ergebnis.push(Math.PI);
                    } else if (nutzereingabe.equals("pow")) {
                        Double ergebnisTmp = ergebnis.pop();
                        System.out.println("         Geben Sie einen "
                                + "\n         Exponenten ein:");
                        System.out.print("      ");
                        ergebnis.push(Math.pow(ergebnisTmp, scan.nextDouble()));
                    } else if (nutzereingabe.equals("e")) {
                        ergebnis.push(Math.E);
                    } else if (nutzereingabe.equalsIgnoreCase("exit")) {
                        System.exit(0);
                    } else {
                        ergebnis.push(zahl);
                    }
                } catch (Exception e) {

                    System.out.println("      Ungültige Eingabe! \n"
                            + "     Bitte erneut versuchen:");
                    i=0;
                    break;
                }
            }
            if (i >= 2 && ergebnis.size() == 1) {
                double finErgebnis = ergebnis.peek();
                System.out.println("            Ergebnis: ");
                System.out.println("            " + finErgebnis);
            }
        }
    }

    public static void eingabe() {
        System.out.println("\n            Eingabe:    ");
        System.out.print("        ");

    }

    public static void willkommen() {
        System.out.println("      U P N-TASCHENRECHNER");
        System.out.println("      ********************");
    }
}
```


----------



## Meniskusschaden (19. Jan 2018)

Warum holt ihr euch die Operanden beim Potenzieren eigentlich nicht ganz normal vom Stack? Das ist so ja eine ziemlich merkwürdige Bedienung.
Ausserdem würde ich den Stack auch nicht löschen, damit man damit weiter rechnen kann.


JStein52 hat gesagt.:


> javabeginners18 hat gesagt.:
> 
> 
> > Kann ich zum Beispiel diesen if-else-Dschungel sauber darstellen
> ...


Stimmt zwar, aber ich finde es mit switch/case trotzdem etwas besser lesbar:

```
switch (nutzereingabe) {
case "+":
    ergebnis.push(ergebnis.pop() + ergebnis.pop());
    break;
case "-":
    ergebnis.push(-ergebnis.pop() + ergebnis.pop());
    break;
case "x":
    ergebnis.push(ergebnis.pop() * ergebnis.pop());
    break;
...
```


----------



## mrBrown (19. Jan 2018)

Meniskusschaden hat gesagt.:


> JStein52 hat gesagt.:
> 
> 
> > javabeginners18 hat gesagt.:
> ...



Switch würd ich in dem Fall auch gegenüber if bevorzugen, da fällt der ganzen Bloat weg...


Mag vllt für Programmieranfänger etwas komplizierter sein, aber am besten finde ich die Variante mit Map (oder passenderem Interface). Vermeidet dann auch die Doppelungen beim prüfen auf valide Eingaben.

Wird dann sowas:

Operation anlegen:

```
operationen.put("+", stack -> stack.push(stack.pop() + stack.pop()));
operationen.put("-", stack -> stack.push(stack.pop() - stack.pop()));
```

Anwenden:

```
operationen.get(nutzereingabe).consume(ergebnis);
```


----------



## javabeginners18 (19. Jan 2018)

@JStein52 Ich habe sehr vieles noch kommentiert, kann ich vielleicht meinen Code einsenden? Bei "Ihrem" Code funktioniert es, aber an sich habe ich eigentlich nichts umgeändert.

@Meniskusschaden & @mrBrown
ich versuche die switch-case-Anweisung zu machen, jedoch gibt er mir das Ergebnis dann nicht mehr aus.. sehr merkwürdig.. mein Prof bevorzugt glaube ich aber auch switch-case..


Der Code wegen @JStein52 



```
import java.util.Scanner;
import java.util.Stack;

public class UPNRechner {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);     // Benutzereingabe
        Scanner scanner = new Scanner(System.in); // zwei Scanner - dieser hier für den "Tokenizer"
        Stack<Double> ergebnis = new Stack();    // Stack mit dem Namen "ergebnis" erstellt
        willkommen();                           // Überschrift/Begrüßungstext

            /*
            while-Schleife, welche den Großteil des Taschenrechners beinhaltet
             */

        int i = 0;
        while (true) {
            eingabefeld();                      // Eingabefeld (Text)
            System.out.print("  ");
            String nextLine = scanner.nextLine();
            Scanner tokenizer = new Scanner(nextLine);  // der "Tokenizer" dient zum Zerlegen der Benutzereingabe
            i = 0;
            ergebnis.clear();

            for (int j = 0; tokenizer.hasNext(); j++) {
                i++;
                String nutzereingabe;
                nutzereingabe = tokenizer.next();
                double zahl = 0.0;

                    /*
                    In dieser try-catch-Anweisung wird die
                    "Umwandlung" von binären und hexadezimalen
                    Codes in Integer ausgeführt. Ebenfalls werden
                    Fehlermeldungen generiert, die eine ungültige
                    Eingabe bestätigen, und interne Fehlermeldungen
                    seitens IntelliJ, die das Programm ungewollt
                    beenden, werden beseitigt.
                     */
                try {
                    if (nutzereingabe.startsWith("0x") || nutzereingabe.startsWith("0X"))
                        zahl = Integer.parseInt(nutzereingabe.substring(2), 16);
                    else if (nutzereingabe.startsWith("-0x") || nutzereingabe.startsWith("-0X"))
                        zahl = Integer.parseInt(nutzereingabe.substring(3), 16);
                    else if (nutzereingabe.startsWith("0b") || nutzereingabe.startsWith("0B"))
                        zahl = Integer.parseInt(nutzereingabe.substring(2), 2);
                    else if (nutzereingabe.startsWith("-0b") || nutzereingabe.startsWith("-0B"))
                        zahl = Integer.parseInt(nutzereingabe.substring(3), 2);
                    else zahl = Double.parseDouble(nutzereingabe);
                }catch (NumberFormatException e) {
                    if (nutzereingabe.equals("+")
                            || nutzereingabe.equals("-")
                            || nutzereingabe.equals("*")
                            || nutzereingabe.equals("x")
                            || nutzereingabe.equals("/")
                            || nutzereingabe.equals(":")
                            || nutzereingabe.equals("÷")
                            || nutzereingabe.equals("pow")
                            || nutzereingabe.equals("cos")
                            || nutzereingabe.equals("sqrt")
                            || nutzereingabe.equals("√")
                            || nutzereingabe.equals("sin")
                            || nutzereingabe.equals("cos")
                            || nutzereingabe.equals("ln")
                            || nutzereingabe.equals("~")
                            || nutzereingabe.equals("e")
                            || nutzereingabe.equals("tan")
                            || nutzereingabe.equals("exp")
                            || nutzereingabe.equals("pi")
                            || nutzereingabe.equals("exit")) {
                    }else{
                        ungueltigeEingabe();
                       
                        i=0;
                        break;
                    }
                }

                    /*
                    In der folgenden try-catch-Anweisung sind die Funk-
                    tionen der Rechenoperatoren definiert - ebenso wird
                    hier geprüft, ob die Eingabe des Benutzers richtig
                    ist und/oder der Reihenfolge entspricht, in der diese
                    sein soll. Falls sich die Eingabe nicht um den Typ
                    Double oder um einen definierten Rechenoperatoren,
                    etc. handelt, soll für den Benutzer eine Fehlermeldung
                    erscheinen, die den Nutzer dazu auffordert, die
                    Handlung in korrekter Weise zu wiederholen.
                    *
                    */

                    /*Hier wurde ein Double "ergebnisTmp" (temporäres
                    Ergebnis) erstellt. Dieser "speichert" den letzten
                    Wert im bzw. "auf" dem Stack. Durch "ergebnis.pop()"
                    wird eine Zahl vom Stapel genommen, mit "ergebnis.push()"
                    hinzugefügt.
                     */

                try {
                    if (nutzereingabe.equals("+")) {                                // Addition im Stack
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() + ergebnisTmp);
                    } else if (nutzereingabe.equals("-")) {                        // Subtraktion im Stack
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() - ergebnisTmp);
                    } else if (nutzereingabe.equals("x") ||                        // Multiplikation im Stack
                            nutzereingabe.equals("*")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() * ergebnisTmp);
                    } else if (nutzereingabe.equals("/") ||                        // Division im Stack
                            (nutzereingabe.equals(":"))) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(ergebnis.pop() / ergebnisTmp);
                    } else if (nutzereingabe.equals("sqrt")                       // Wurzelziehen
                            || nutzereingabe.equals("√")){
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.sqrt(ergebnisTmp));
                    } else if (nutzereingabe.equals("sin")) {                     // Sinus-Funktion
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.sin(ergebnisTmp));
                    } else if (nutzereingabe.equals("cos")) {                     // Cosinus-Funktion
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.cos(ergebnisTmp));
                    } else if (nutzereingabe.equals("tan")) {                     // Tangens-Funktion
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.tan(ergebnisTmp));
                    } else if (nutzereingabe.equals("~")) {                       // Vorzeichen
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push((ergebnisTmp * (-1)));
                    } else if (nutzereingabe.equals("ln")) {                       // ln-Logarithmus
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.log(ergebnisTmp));
                    } else if (nutzereingabe.equals("exp")) {                      // E-Funktion
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.pow(Math.E, ergebnisTmp));
                    } else if (nutzereingabe.equals("pi") ||                        // pi-Funktion
                            nutzereingabe.equals("π")) {
                        ergebnis.push(Math.PI);
                    } else if (nutzereingabe.equals("pow")) {                       // Exponent einer Zahl
                        Double ergebnisTmp = ergebnis.pop();
                        exponenteingeben();
                        ergebnis.push(Math.pow(ergebnisTmp, scan.nextDouble()));
                    } else if (nutzereingabe.equals("e")) {                          // Eulersche Zahl
                        ergebnis.push(Math.E);
                    } else if (nutzereingabe.equalsIgnoreCase("exit")) {  // Verlassen des Programms
                        System.exit(0);
                    } else {
                        ergebnis.push(zahl);
                    }
                }catch (Exception e) {
                    ungueltigeEingabe();                         // ungültige Eingabe
                   
                    i=0;
                    break;
                }
            }
            if (ergebnis.size() == 1) {                        // Wenn die Größe vom Stack "ergebnis" 1 beträgt und der Stack am Ende angelangt ist,..
                double finErgebnis = ergebnis.peek();          // ..soll mit .peek() das Ergebnis angezeigt werden.
                System.out.print("      Ergebnis: ");
                System.out.println(finErgebnis);
                System.out.println("                       ");
            }
        }
    }
    public static void eingabefeld() {
        System.out.println("      ********************");
        System.out.print("      Eingabe:");

    }               // "Eingabe:" vor der Benutzereingabe
    public static void willkommen() {
        System.out.println("                          ");
        System.out.println("      U P N-TASCHENRECHNER");
    }               // Begrüßung
    public static void ungueltigeEingabe() {
        System.out.println("      Ungültige Eingabe. \n" +
                "      Bitte erneut versuchen!");
    }       // ungültige Benutzereingabe
    public static void exponenteingeben() {
        System.out.print("      Geben Sie einen " +"\n" +
                "      Exponenten ein:    ");
    }       // Exponent eingeben
}
```


----------



## javabeginners18 (19. Jan 2018)

Ich habe mal versucht switch-case einzubauen, wahrscheinlich wieder etwas vergessen oder nicht beachtet.. jetzt gibt er die Rechnung nicht aus

```
import java.util.Scanner;
import java.util.Stack;




public class UPNRechner {

    public static void main(String[] args) {

        Scanner scan = new Scanner(System.in);     // Benutzereingabe
        Scanner scanner = new Scanner(System.in); // zwei Scanner - dieser hier für den "Tokenizer"
        Stack<Double> ergebnis = new Stack();    // Stack mit dem Namen "ergebnis" erstellt
        willkommen();                           // Überschrift/Begrüßungstext

            /*
            while-Schleife, welche den Großteil des Taschenrechners beinhaltet
             */

        int i = 0;
        while (true) {
            eingabefeld();                      // Eingabefeld (Text)
            System.out.print("  ");
            String nextLine = scanner.nextLine();
            Scanner tokenizer = new Scanner(nextLine);  // der "Tokenizer" dient zum Zerlegen der Benutzereingabe
            i = 0;
            ergebnis.clear();

            for (int j = 0; tokenizer.hasNext(); j++) {
                i++;
                String nutzereingabe;
                nutzereingabe = tokenizer.next();
                double zahl = 0.0;

                    /*
                    In dieser try-catch-Anweisung wird die
                    "Umwandlung" von binären und hexadezimalen
                    Codes in Integer ausgeführt. Ebenfalls werden
                    Fehlermeldungen generiert, die eine ungültige
                    Eingabe bestätigen, und interne Fehlermeldungen
                    seitens IntelliJ, die das Programm ungewollt
                    beenden, werden beseitigt.
                     */
                try {
                    if (nutzereingabe.startsWith("0x") || nutzereingabe.startsWith("0X"))
                        zahl = Integer.parseInt(nutzereingabe.substring(2), 16);
                    else if (nutzereingabe.startsWith("-0x") || nutzereingabe.startsWith("-0X"))
                        zahl = Integer.parseInt(nutzereingabe.substring(3), 16);
                    else if (nutzereingabe.startsWith("0b") || nutzereingabe.startsWith("0B"))
                        zahl = Integer.parseInt(nutzereingabe.substring(2), 2);
                    else if (nutzereingabe.startsWith("-0b") || nutzereingabe.startsWith("-0B"))
                        zahl = Integer.parseInt(nutzereingabe.substring(3), 2);
                    else zahl = Double.parseDouble(nutzereingabe);
                }catch (NumberFormatException e) {
                    if (nutzereingabe.equals("+")
                            || nutzereingabe.equals("-")
                            || nutzereingabe.equals("*")
                            || nutzereingabe.equals("x")
                            || nutzereingabe.equals("/")
                            || nutzereingabe.equals(":")
                            || nutzereingabe.equals("÷")
                            || nutzereingabe.equals("pow")
                            || nutzereingabe.equals("cos")
                            || nutzereingabe.equals("sqrt")
                            || nutzereingabe.equals("√")
                            || nutzereingabe.equals("sin")
                            || nutzereingabe.equals("cos")
                            || nutzereingabe.equals("ln")
                            || nutzereingabe.equals("~")
                            || nutzereingabe.equals("e")
                            || nutzereingabe.equals("tan")
                            || nutzereingabe.equals("exp")
                            || nutzereingabe.equals("pi")
                            || nutzereingabe.equals("exit")) {
                    }else{
                        ungueltigeEingabe();

                        i=0;
                        break;
                    }
                }

                    /*
                    In der folgenden try-catch-Anweisung sind die Funk-
                    tionen der Rechenoperatoren definiert - ebenso wird
                    hier geprüft, ob die Eingabe des Benutzers richtig
                    ist und/oder der Reihenfolge entspricht, in der diese
                    sein soll. Falls sich die Eingabe nicht um den Typ
                    Double oder um einen definierten Rechenoperatoren,
                    etc. handelt, soll für den Benutzer eine Fehlermeldung
                    erscheinen, die den Nutzer dazu auffordert, die
                    Handlung in korrekter Weise zu wiederholen.
                    *
                    */

                    /*Hier wurde ein Double "ergebnisTmp" (temporäres
                    Ergebnis) erstellt. Dieser "speichert" den letzten
                    Wert im bzw. "auf" dem Stack. Durch "ergebnis.pop()"
                    wird eine Zahl vom Stapel genommen, mit "ergebnis.push()"
                    hinzugefügt.
                     */

                try {
                    Double ergebnisTmp = ergebnis.pop();
                    switch (nutzereingabe) {
                        case "+":
                            ergebnis.push(ergebnis.pop() + ergebnis.pop());
                            break;
                        case "-":
                            ergebnis.push(ergebnis.pop() - ergebnis.pop());
                            break;
                        case "*":
                            ergebnis.push(ergebnis.pop() * ergebnis.pop());
                            break;
                        case "x":
                            ergebnis.push(ergebnis.pop() * ergebnis.pop());
                            break;
                        case "/":
                            ergebnis.push(ergebnis.pop() * ergebnis.pop());
                            break;
                        case ":":
                            ergebnis.push(ergebnis.pop() * ergebnis.pop());
                            break;
                        case "÷":
                            ergebnis.push(ergebnis.pop() * ergebnis.pop());
                            break;
                        case "sqrt":
                            ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.sqrt(ergebnisTmp));
                            break;
                        case "√":
                            ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.sqrt(ergebnisTmp));
                            break;
                        case "sin":
                            ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.sin(ergebnisTmp));
                            break;
                        case "cos":
                            ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.cos(ergebnisTmp));
                            break;
                        case "tan":
                            ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.tan(ergebnisTmp));
                            break;
                        case "~":
                            ergebnisTmp = ergebnis.pop();
                            ergebnis.push((ergebnisTmp * (-1)));
                            break;
                        case "exp":
                            ergebnisTmp = ergebnis.pop();
                            ergebnis.push(Math.pow(Math.E, ergebnisTmp));
                            break;
                        case "pi":
                            ergebnis.push(Math.PI);
                            break;
                        case "π":
                            ergebnis.push(Math.PI);
                            break;
                        case "e":
                            ergebnis.push(Math.E);
                            break;
                        case "pow":
                            ergebnisTmp = ergebnis.pop();
                            exponenteingeben();
                            ergebnis.push(Math.pow(ergebnisTmp, scan.nextDouble()));
                            break;
                        case "exit":
                            System.exit(0);
                            break;
                        default:
                            ergebnis.push(zahl);
                    }
                    }catch (Exception e) {
                    ungueltigeEingabe();                         // ungültige Eingabe

                    i=0;
                    break;
                }
            }
            if (ergebnis.size() == 1) {                        // Wenn die Größe vom Stack "ergebnis" 1 beträgt und der Stack am Ende angelangt ist,..
                double finErgebnis = ergebnis.peek();          // ..soll mit .peek() das Ergebnis angezeigt werden.
                System.out.print("      Ergebnis: ");
                System.out.println(finErgebnis);
                System.out.println("                       ");
            }
        }
    }
    public static void eingabefeld() {
        System.out.println("      ********************");
        System.out.print("      Eingabe:");

    }               // "Eingabe:" vor der Benutzereingabe
    public static void willkommen() {
        System.out.println("                          ");
        System.out.println("      U P N-TASCHENRECHNER");
    }               // Begrüßung
    public static void ungueltigeEingabe() {
        System.out.println("      Ungültige Eingabe. \n" +
                "      Bitte erneut versuchen!");
    }       // ungültige Benutzereingabe
    public static void exponenteingeben() {
        System.out.print("      Geben Sie einen " +"\n" +
                "      Exponenten ein:    ");
    }       // Exponent eingeben
}
```


----------



## Meniskusschaden (19. Jan 2018)

javabeginners18 hat gesagt.:


> jetzt gibt er die Rechnung nicht aus


Einfach so? Oder gibt es auch eine Fehlermeldung?


----------



## javabeginners18 (19. Jan 2018)

Meniskusschaden hat gesagt.:


> Einfach so? Oder gibt es auch eine Fehlermeldung?



Also mit der integrierten Fehlermeldung "Ungültige Eingabe........."


----------



## mrBrown (19. Jan 2018)

Lasst euch doch einfach mal die Exception ausgeben, die der Grund für die Fehlermeldung ist


----------



## Meniskusschaden (19. Jan 2018)

Dann würde ich - zumindest vorübergehend - in den catch-Blöcken `e.printStackTrace()` aufrufen. Im StackTrace müsste man die Ursache dann sehen.


----------



## javabeginners18 (19. Jan 2018)

ich habe das mit dem e.printStackTrace() gemacht, da kommt dann folgende Fehlermeldung: 

      U P N-TASCHENRECHNER
      ********************
      Eingabe:  3 3 + 
java.util.EmptyStackException
    at java.base/java.util.Stack.peek(Stack.java:102)
    at java.base/java.util.Stack.pop(Stack.java:84)
    at UPNRechner.main(UPNRechner.java:114)
      Ungültige Eingabe. 
      Bitte erneut versuchen!
      ********************
      Eingabe:


----------



## Meniskusschaden (19. Jan 2018)

Ja, aber jetzt hast du Informationen über die Ursache. Ein StackTrace kann sehr lang werden. Deshalb würde ich mir die eigentliche Meldung ansehen (java.util.EmptyStackException) und die erste Zeile, die zu einer selbst programmierten Klasse gehört (Zeile 114). Da liegt das Problem.


----------



## javabeginners18 (19. Jan 2018)

Hmm ich versteh das nicht so genau.. bin eben ein Anfänger

....
try {
* Double ergebnisTmp = ergebnis.pop();*
    switch (nutzereingabe) {
        case "+":
            ergebnis.push(ergebnis.pop() + ergebnis.pop());
            break;
            ....


das rote soll der Fehler sein... hmm


----------



## Meniskusschaden (19. Jan 2018)

In der Zeile willst du dir offenbar etwas vom Stack holen, was aber nicht funktioniert, weil er gerade leer ist. Warum möchtest du an der Stelle denn etwas vom Stack holen?


----------



## javabeginners18 (19. Jan 2018)

Ok, das hat sich soweit geklärt  
Beim switch-case braucht man kein temporäres Ergebnis (ergebnisTmp), ich weiß nicht ob es anders auch so gegangen wäre, aber hier geht das jetzt auch nur mit dem ergebnis.pop().


----------



## javabeginners18 (19. Jan 2018)

Jetzt wäre der Rechner eigentlich fertig von den Funktionen,
das andere Problem, in dem das Ergebnis trotzdem gekommen ist
habe ich gelöst, in dem ich den alten Code genommen habe,
wahrscheinlich ist mir da etwas Falsches reingerutscht.

Jetzt hätte ich noch einige Wissensfragen, da ich auch kurze Kommentare
über die Funktion schreiben muss:

Was hat dieser Block genau für eine Funktion?  Danke schonmal.

```
...
for (int j = 0; tokenizer.hasNext(); j++) {
                i++;
                String nutzereingabe;
                nutzereingabe = tokenizer.next();
                double zahl = 0.0;
...
```


----------



## javabeginners18 (19. Jan 2018)

*Nur noch kurz eine Frage zu dem Rechner:*
Wenn ich zum Beispiel nur eine Zahl wie zum Beispiel 5 eingebe
und Enter drücke, kommt einfach nochmal "Eingabe:" ohne dass
es eine Fehlermeldung "Ungültige Eingabe" ausgibt. Wie kann ich
das auch hinbekommen?


----------



## Meniskusschaden (19. Jan 2018)

javabeginners18 hat gesagt.:


> Wenn ich zum Beispiel nur eine Zahl wie zum Beispiel 5 eingebe
> und Enter drücke, kommt einfach nochmal "Eingabe:" ohne dass
> es eine Fehlermeldung "Ungültige Eingabe" ausgibt.


Für mich wäre das eine gültige Eingabe. Wenn man 5 eingibt kommt eben 5 heraus. Was ist daran falsch?
Problematisch finde ich eher, dass kein Ergebnis angezeigt wird, wenn der Stack noch mehrere Elemente enthält. Ein echter UPN-Rechner lässt die einfach liegen. Vielleicht will man ja später etwas damit machen. Ich würde beispielsweise folgendes erwarten:

```
>3 3 x 4 4 x
Stack: 9, 16
Anzeige: 16
>+
Stack: 25, Anzeige: 25
```
Sonst kann man ja gar keine Kettenrechnungen mit Zwischenergebnissen machen.


----------



## javabeginners18 (19. Jan 2018)

Meniskusschaden hat gesagt.:


> Sonst kann man ja gar keine Kettenrechnungen mit Zwischenergebnissen machen.




Also der Prof. hat gemeint, dass unser Projekt nur das Endergebnis anzeigen soll. Wäre auch fürs erste Semester etwas weit hergeholt, finde ich. 



Meniskusschaden hat gesagt.:


> Wenn man 5 eingibt kommt eben 5 heraus. Was ist daran falsch?



Kommt eben nicht raus, sondern es fängt einfach eine neue Rechnung an.


----------



## Meniskusschaden (19. Jan 2018)

javabeginners18 hat gesagt.:


> Also der Prof. hat gemeint, dass unser Projekt nur das Endergebnis anzeigen soll. Wäre auch fürs erste Semester etwas weit hergeholt, finde ich.


Ist dadurch nicht schwieriger. Man löscht den Stack eben nicht und gibt immer das oberste Element aus. Wäre meines Erachtens sogar ein wenig einfacher.


javabeginners18 hat gesagt.:


> Kommt eben nicht raus, sondern es fängt einfach eine neue Rechnung an.


Kann ich nicht nachvollziehen. Bei mir sieht es so aus, wenn ich 5 eingebe:

```
U P N-TASCHENRECHNER
      ********************
      Eingabe:  5
      Ergebnis: 5.0
                     
      ********************
      Eingabe:
```


----------



## Meniskusschaden (19. Jan 2018)

javabeginners18 hat gesagt.:


> Also der Prof. hat gemeint, dass unser Projekt nur das Endergebnis anzeigen soll.


Das widerspricht meinem Beispiel ja nicht. Den Stack habe ich zum Verständnis angegeben. Ausgegeben würde nur jeweils der Anzeigewert.


----------



## Meniskusschaden (19. Jan 2018)

Übrigens rechnet dein Programm bei nicht kommutativen Operationen nicht mehr richtig:

```
U P N-TASCHENRECHNER
      ********************
      Eingabe:  5 2 -
      Ergebnis: -3.0
                     
      ********************
      Eingabe:
```


----------



## javabeginners18 (19. Jan 2018)

Meniskusschaden hat gesagt.:


> Übrigens rechnet dein Programm bei nicht kommutativen Operationen nicht mehr richtig:
> 
> ```
> U P N-TASCHENRECHNER
> ...



Habe den Fehler gefunden, war in dem Fall Minus und Plus vertauscht...


----------



## mrBrown (19. Jan 2018)

javabeginners18 hat gesagt.:


> Also der Prof. hat gemeint, dass unser Projekt nur das Endergebnis anzeigen soll. Wäre auch fürs erste Semester etwas weit hergeholt, finde ich.


Da stimm ich @Meniskusschaden zu, das wäre eher leichter geworden 



javabeginners18 hat gesagt.:


> Habe den Fehler gefunden, war in dem Fall Minus und Plus vertauscht...



Das Problem ist eher was anderes, nur in diesem Spezialfall ist’s +/- vertauscht...

Probier mal dividieren (wenn es denn jetzt implementiert ist), da sollte das auch auftreten.


----------



## javabeginners18 (19. Jan 2018)

Oh ja, hast vollkommen recht.. ich habe in der switch-Anweisung einfach beim Minus, wie hier schon empfohlen wurde, ein Minus vor das Ergebnis.pop()... wie löse ich das am Besten?


----------



## mrBrown (19. Jan 2018)

Indem du rausfindest, warum das Problem auftritt


----------



## javabeginners18 (19. Jan 2018)

Oh man, kannst du mir nicht vielleicht helfen? Die Abgabe ist in wenigen Stunden


----------



## mrBrown (19. Jan 2018)

Einfach mal einen klitzekleinen Schreibtischtest machen, das Problem ist dann recht offensichtlich


----------



## javabeginners18 (19. Jan 2018)

Habe es rausgefunden, danke.


----------



## javabeginners18 (19. Jan 2018)

Ok, das wird dann wohl meine allerletzte Frage zu diesem Thema sein:

Kann man zu dieser Art von Code bzw. ohne Methoden ein oder zwei 
JUnit-Tests einbauen? Zum Beispiel dass wenn die Nutzereingabe 3 3 + 
ist, dass 6 rauskommt, oder wenn man 3 3 * 4 4 * + sqrt (sqrt steht für Wurzel) eingibt,
das Ergebnis bzw. Stack 5 ist? Das wäre wirklich das letzte, dann wäre ich fertig  ich versuche das schon seit Stunden


----------



## mrBrown (19. Jan 2018)

Man _kann_ schon - allerdings _willst_ du dir das nicht antun, das Programm ist leider extrem untestbar geschrieben 

(System.in und System.out austauschen, passende Eingabe nach System.in schreiben und prüfen, ob in System.out das passende auftaucht)


----------



## Xyz1 (19. Jan 2018)

Kannst du nochmal von vorne anfangen? Wofür steht RPN?


----------



## Meniskusschaden (19. Jan 2018)

DerWissende hat gesagt.:


> Wofür steht RPN?


https://en.wikipedia.org/wiki/Reverse_Polish_notation


----------



## Xyz1 (19. Jan 2018)

(R)*PN* konnte ich schon erraten, aber das (R) -(copyright ist nicht damit gemeint  )- sagte mir noch nichts...... also was normales Posfix-notation? POSTFIXNOTATION

Bearbeitung: Also - "_die schlechten ins Kröpfchen_, _die guten ins Töpfchen_" und dann nochmal wiederholen pull en und push en.


----------

