RPN Taschenrechner - keine Lösung!!

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:

Java:
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!");
    }
}
 
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
 

Meniskusschaden

Top Contributor
Ä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).
 
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. :)
 
Zuletzt bearbeitet:

Meniskusschaden

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

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

Administrator
Mitarbeiter
Java:
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...
 

JStein52

Top Contributor
Hier mal auf die Schnelle euer Programm umgebaut:
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();

        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!");
    }
}
 
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

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

Top Contributor
Ergibt dann so was:

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

Und da:
Code:
                } 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

Top Contributor
Hier ist auch noch ein Fehlerlein:
Code:
                } else if (nutzereingabe.equals("exp")) {
                    Double ergebnisTmp = ergebnis.pop();
                    ergebnis.push(Math.pow(2.71828182846, 1));
sollte wohl
Code:
                } 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
 
Wow, besser als mein Prof :D 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

Top Contributor
Hier noch zur Kontrolle die pi-Geschichte:
Code:
                            || nutzereingabe.equals("tan")
                            || nutzereingabe.equals("pi")
                            || nutzereingabe.equals("exp")
und
Code:
                } 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);
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 ?
 
Ich habe das mal probiert, da kommt jedoch eine Exception, habe das auch beim catch eingefügt:
Java:
...
} else if (nutzereingabe.equals("pi")) {
                        Double ergebnisTmp = ergebnis.pop();
                        ergebnis.push(Math.PI);
 
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
 
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?
 
Oh stimmt, das habe ich gar nicht bemerkt :oops:
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

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

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

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
            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("      ********************");
        }
}
 
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

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

Top Contributor
Und wenn du eingabe() an dieser Stelle aufrufst kommt es dem wie du es willst schon näher:
Code:
            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
 
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

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

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

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

Top Contributor
Du hast weiter unten nochmal ein Double.parseDouble drin gehabt, das muss ersatzlos raus. zahl enthält ja schon den richtigen Wert.
Code:
                        } 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;
 
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:
 
Ä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