RPN Taschenrechner - keine Lösung!!

JStein52

Top Contributor
ok,
suche nach break und mache folgendes:
Code:
                        i = 0;
                        break;
Achtung, kommt zweimal vor. Das verhindert die Ausgabe.
 
ok,
suche nach break und mache folgendes:
Code:
                        i = 0;
                        break;
Achtung, kommt zweimal vor. Das verhindert die Ausgabe.


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
 
Zuletzt bearbeitet:

JStein52

Top Contributor
Mhmm bei mir funktioniert es:
Code:
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

Top Contributor
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.
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.
Stimmt zwar, aber ich finde es mit switch/case trotzdem etwas besser lesbar:
Java:
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

Super-Moderator
Mitarbeiter
Kann ich zum Beispiel diesen if-else-Dschungel sauber darstellen? Geht das überhaupt in der Form mit einem switch-case?
Würde ich so lassen denn swith case gibt den gleichen Dschungel nur mit anderen Schlüsselworten.

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

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:
Java:
operationen.put("+", stack -> stack.push(stack.pop() + stack.pop()));
operationen.put("-", stack -> stack.push(stack.pop() - stack.pop()));

Anwenden:
Java:
operationen.get(nutzereingabe).consume(ergebnis);
 
@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


Java:
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
}
 
Ich habe mal versucht switch-case einzubauen, wahrscheinlich wieder etwas vergessen oder nicht beachtet.. jetzt gibt er die Rechnung nicht aus
Java:
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
}
 
Zuletzt bearbeitet:
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

Top Contributor
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.
 
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

Top Contributor
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?
 
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().
 
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.
Java:
...
for (int j = 0; tokenizer.hasNext(); j++) {
                i++;
                String nutzereingabe;
                nutzereingabe = tokenizer.next();
                double zahl = 0.0;
...
 
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

Top Contributor
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:
Code:
>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.
 

Meniskusschaden

Top Contributor
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.
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:
Code:
      U P N-TASCHENRECHNER
      ********************
      Eingabe:  5
      Ergebnis: 5.0
                     
      ********************
      Eingabe:
 

Meniskusschaden

Top Contributor
Übrigens rechnet dein Programm bei nicht kommutativen Operationen nicht mehr richtig:
Code:
      U P N-TASCHENRECHNER
      ********************
      Eingabe:  5 2 -
      Ergebnis: -3.0
                     
      ********************
      Eingabe:
 

mrBrown

Super-Moderator
Mitarbeiter
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 ;)

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.
 
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?
 
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

Super-Moderator
Mitarbeiter
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)
 
X

Xyz1

Gast
(R)PN konnte ich schon erraten, aber das (R) -(copyright ist nicht damit gemeint :D )- 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.
 
Zuletzt bearbeitet von einem Moderator:
Ähnliche Java Themen
  Titel Forum Antworten Datum
K Erste Schritte "Taschenrechner" zeigt keine Komma Zahlen an. Java Basics - Anfänger-Themen 8
N Java Taschenrechner hat Jemand vlt einen Tipp dafür wie ich jetzt die buttons verbinden kann und das Ergebnis auf dem textfield anzeigen lassen kann Java Basics - Anfänger-Themen 13
L Taschenrechner Problem Java Basics - Anfänger-Themen 4
J Frage zu einem "Taschenrechner" code Java Basics - Anfänger-Themen 9
R Operatoren Rechenoperation verwenden für Taschenrechner. Java Basics - Anfänger-Themen 32
S while Schleife Taschenrechner Java Basics - Anfänger-Themen 1
J Taschenrechner mit mehr als 2 Zahlen. Java Basics - Anfänger-Themen 18
R Einfacher Taschenrechner mit Eclipse Java Basics - Anfänger-Themen 3
M Einfacher Taschenrechner Java Basics - Anfänger-Themen 2
Fiedelbambu Prüfen von Komma stelle beim Taschenrechner Java Basics - Anfänger-Themen 5
JordenJost Taschenrechner problem Java Basics - Anfänger-Themen 5
Y Taschenrechner programmieren Java Basics - Anfänger-Themen 3
G Taschenrechner ergibt Fehler in if-Abfrage Java Basics - Anfänger-Themen 6
C Potenzberechnung über switch case. Taschenrechner mit Eingabe über einen grafischen Dialog Java Basics - Anfänger-Themen 22
E JavaFX Taschenrechner Eingabe im Textfield beschränken Java Basics - Anfänger-Themen 2
E Taschenrechner GUI Problem mit Fehlerhandling Java Basics - Anfänger-Themen 6
C Taschenrechner (switch) in Taschenrechner mit Methoden umwandeln Java Basics - Anfänger-Themen 115
W Taschenrechner mit Switch case Java Basics - Anfänger-Themen 4
W Taschenrechner Java Basics - Anfänger-Themen 11
A Taschenrechner mit Gui erstellen Java Basics - Anfänger-Themen 9
2 Taschenrechner mit GUI Problem bei der Berechnung Java Basics - Anfänger-Themen 8
P Taschenrechner mit unendlich vielen Eingabemöglichkeiten Java Basics - Anfänger-Themen 1
V Erste Schritte Taschenrechner mit beliebig vielen Zahlen Java Basics - Anfänger-Themen 5
S Taschenrechner Java Basics - Anfänger-Themen 13
P Taschenrechner Text übertragung Java Basics - Anfänger-Themen 3
S Compiler-Fehler Basic- Taschenrechner/ Fehler Java Basics - Anfänger-Themen 8
S Basic- Taschenrechner? Java Basics - Anfänger-Themen 7
P Hilfe bei Java Taschenrechner Java Basics - Anfänger-Themen 25
F Erste Schritte Frage zu simplem Taschenrechner(switch) Java Basics - Anfänger-Themen 16
L Mein Taschenrechner lässt sich plötzlich nicht mehr öffnen Java Basics - Anfänger-Themen 5
S Taschenrechner hilfe! Java Basics - Anfänger-Themen 17
H Java Taschenrechner Java Basics - Anfänger-Themen 4
R Variablen Taschenrechner mit Komfortfunktionen Java Basics - Anfänger-Themen 2
M Java Taschenrechner (if-else) Java Basics - Anfänger-Themen 11
L Taschenrechner mit switch und while funktioniert noch nicht richtig Java Basics - Anfänger-Themen 22
Q simpler Taschenrechner Java Basics - Anfänger-Themen 34
R Taschenrechner NullPointerException Java Basics - Anfänger-Themen 1
R Variablen Weitergehenderr Taschenrechner Java Basics - Anfänger-Themen 4
F Taschenrechner "Error loading class..." Java Basics - Anfänger-Themen 5
M Java Taschenrechner Programmieren Java Basics - Anfänger-Themen 12
P Erste Schritte Taschenrechner mit if-else Anweisung Java Basics - Anfänger-Themen 6
G Taschenrechner gibt nur 0.0 aus Java Basics - Anfänger-Themen 8
A Taschenrechner programmieren Java Basics - Anfänger-Themen 21
Z Java Taschenrechner Java Basics - Anfänger-Themen 6
J Kleiner Taschenrechner! Anfänger braucht Hilfe :( Java Basics - Anfänger-Themen 2
C Taschenrechner in Java Java Basics - Anfänger-Themen 6
J Erste Schritte Java CMD Taschenrechner mit Parametern! Java Basics - Anfänger-Themen 16
J Taschenrechner: Probleme Java Basics - Anfänger-Themen 5
E Taschenrechner problem! Ich komme nicht voran Java Basics - Anfänger-Themen 18
R Erste Schritte Taschenrechner mit Schleife Java Basics - Anfänger-Themen 24
Lord.Djerun (Taschenrechner Netbeans) Komma nur einmal schreiben & 0 ersetzen Java Basics - Anfänger-Themen 1
Z Taschenrechner - Additions/Substraktions/Multiplikations/Divionsketten! Java Basics - Anfänger-Themen 4
D Taschenrechner Frage Java Basics - Anfänger-Themen 12
Z Sehr simpler Taschenrechner - Hilfe! Java Basics - Anfänger-Themen 10
Z Taschenrechner - Wie addiere,multipliziere und subtrahiere ich? Java Basics - Anfänger-Themen 6
D kleiner Taschenrechner mit switch fehlerhaft Java Basics - Anfänger-Themen 1
K Taschenrechner im GUI Java Basics - Anfänger-Themen 2
P Taschenrechner, operatoren Java Basics - Anfänger-Themen 4
D Simpler Taschenrechner Java Basics - Anfänger-Themen 6
A Anfänger Taschenrechner Frage Java Basics - Anfänger-Themen 14
R Erste Schritte Taschenrechner - Punkt-vor-Strich Rechnung Java Basics - Anfänger-Themen 1
S Operatoren Taschenrechner Ergebnis ausgeben Java Basics - Anfänger-Themen 7
A Taschenrechner zeigt Error Java Basics - Anfänger-Themen 7
J Taschenrechner Funktion Java Basics - Anfänger-Themen 18
M Taschenrechner fertigstellung Java Basics - Anfänger-Themen 1
N Methoden Taschenrechner Java Basics - Anfänger-Themen 2
F z = input.nextChar(); PROBLEM Taschenrechner Java Basics - Anfänger-Themen 7
J Scanner Taschenrechner? Java Basics - Anfänger-Themen 7
J Variablen Rechenzeichen und Zahlen verknüpfen für einen Taschenrechner Java Basics - Anfänger-Themen 17
B Klassen Java Taschenrechner mit Klassen und Methoden Java Basics - Anfänger-Themen 12
B Erste Schritte Brauche Hilfe bei einem Java-Taschenrechner Java Basics - Anfänger-Themen 11
R Methoden Taschenrechner Java Basics - Anfänger-Themen 4
P Taschenrechner , IF-Abfrage Java Basics - Anfänger-Themen 12
I Taschenrechner - Methoden implementieren Java Basics - Anfänger-Themen 5
I Java Starthilfe (Taschenrechner) Java Basics - Anfänger-Themen 7
J Taschenrechner Problemchen Java Basics - Anfänger-Themen 3
D Erste Schritte Taschenrechner Java Basics - Anfänger-Themen 11
K taschenrechner - Fehler beim Kürzen eines Bruches finden Java Basics - Anfänger-Themen 20
J Taschenrechner Punkt vor Strich Java Basics - Anfänger-Themen 9
A Taschenrechner programmieren Java Basics - Anfänger-Themen 5
M Ausklappbares Fenster bei grafischem Taschenrechner Java Basics - Anfänger-Themen 2
M Dividieren bei Grafischem Taschenrechner klappt nicht Java Basics - Anfänger-Themen 2
N Taschenrechner mit Unterprogra Java Basics - Anfänger-Themen 6
C Taschenrechner Java Basics - Anfänger-Themen 12
Z Taschenrechner programmieren Java Basics - Anfänger-Themen 5
E Erste Schritte Taschenrechner Java Basics - Anfänger-Themen 8
K Taschenrechner Java Basics - Anfänger-Themen 25
J Textfeld für Taschenrechner Java Basics - Anfänger-Themen 3
D Taschenrechner Java Basics - Anfänger-Themen 28
A Taschenrechner-GUI mit BorderLayout? Java Basics - Anfänger-Themen 6
W [PROJEKT] Simpler grafischer Taschenrechner Java Basics - Anfänger-Themen 8
M Taschenrechner mit JApplet Java Basics - Anfänger-Themen 26
J Grafischen Taschenrechner programmieren - Frage dazu Java Basics - Anfänger-Themen 12
W Taschenrechner Java Basics - Anfänger-Themen 2
T Tasten vom Taschenrechner? Java Basics - Anfänger-Themen 3
S Datentypen Taschenrechner Java Basics - Anfänger-Themen 13
J Taschenrechner Java Basics - Anfänger-Themen 5
J Taschenrechner Java Basics - Anfänger-Themen 9
M While bei einem Taschenrechner Java Basics - Anfänger-Themen 5
F Datentypen Ganz simpler Taschenrechner mit switch Java Basics - Anfänger-Themen 10

Ähnliche Java Themen

Neue Themen


Oben