Rechner: Wert zwischenspeichern und bei Bedarf mit Ihm weiterrechnen?

[Alex_99]

Hallo,

Ich arbeite gerade an meinem ersten komplexeren Java Projekt, und es geht darum einen Rechner zu erstellen, der auch Werte zwischenspeichern kann und bei Bedarf den zwischengespeicherten Wert wieder in den Hauptspeicher schreiben kann um mit Ihm weiterrechnen zu können.
Das Programm ist kommandozeilenbasiert und funktioniert mit Variablen.

case "d":
            Main.speichern = 0;
            System.out.println("Speicher geloescht. Es befindet sich: " + Main.speichern + " im Speicher\n");
            Rechner.nachergebnis();
            break;
        case "s":
             Main.speichern = Main.speicher_alt;
            System.out.println("Wert " + Main.speichern + "Wurde in den Zwischenspeicher geladen\n");
            Rechner.nachergebnis();
        case "l":
            Main.speicher_alt = Main.speichern;
            System.out.println("Wert " + Main.speicher_alt + "Wurde aus Zwischenspeicher nach Speicher geladen\n");
            System.out.println("Es kann mit dem alten Wert weitergerechnet werden.");
            Rechner.nachergebnis();
        }

Wenn nun also "s" auf der Tastatur gedrückt wird soll der Wert aus double "Speichern" in den double "Speicher_alt" gespeichert werden.
Wenn man jetzt eine neue Berechnung durchführt dessen Ergebnis in "Speichern" gesichert wird soll man die Möglichkeit haben den alten Wert der in Variable Speicher_alt liegt wieder mit Tastendruck "l" in die Variable "Speicher" zu laden und damit zu rechnen.

Problem: Wenn "s" gedrückt wird dann wird "speicher" 0.0 und verliert den alten Wert, was ja nicht gewünscht ist.

Mit Tastendruck "d" wird der Speicher mit einer 0 überschrieben was wunderbar funktioniert.

Was kann ich tun um die Funktion zu implementieren?

 

[KonradN]

Da fehlt ein break; beim „s“ Fall. Aber die Fehlerbeschreibung ist so vage und der Codeausschnitt zu klein um wirkliche Aussagen zu treffen.

 

[mihe7]

Außerdem:

Wenn nun also "s" auf der Tastatur gedrückt wird soll der Wert aus double "Speichern" in den double "Speicher_alt" gespeichert werden.

Zeile 7 macht es genau umgekehrt: der Wert aus speicher_alt wird in speichern abgelegt.

 

[Alex_99]

Hier ein Beispiel:

Wenn zahl1 ist ein double und zahl 2 ist ein double beide in der Klasse deklariert mit:

public static double zahl1;

public static double zahl2;

Wenn jetzt addiert wird funktioniert das so:

 public static void rechner() {
        System.out.println("Bitte eine Zahl eingeben");
        System.out.print("Eingabe: ");
        zahl1 = eingabe.nextDouble();

        System.out.println("\nBitte Operator eingeben");
        System.out.println("Alternativ p fuer Prozentrechner");
        System.out.print("Eingabe: ");
        operator = eingabe.next();
        if (Objects.equals(operator, "p")){
            Rechner.bruchwahl();
        }

        System.out.println("\nBitte zweite Zahl eingeben");
        System.out.print("Eingabe: ");
        zahl2 = eingabe.nextDouble();

        switch (operator) {
            case "+":
                System.out.println("\nDas Ergebnis ist: " + (ergebnis = zahl1 + zahl2));
                Main.speichern = ergebnis;
                break;

Dann geht er in die andere Funktion und tut folgendes:

public static void nachergebnis() {
        Scanner eingabe = new Scanner(System.in);
        System.out.println("-------------------------------------------");
        System.out.println("Bitte Aktion waehlen:");
        System.out.println("-------------------------------------------");
        System.out.println("1 - weiterrechnen mit Ergebnis");
        System.out.println("2 - Neue Rechnung");
        System.out.println("3 - Rechner Menue");
        System.out.println("4 - Hauptmenue");
        System.out.println("d - Speicher loeschen");
        System.out.println("a - Speicher ausgeben");
        System.out.println("s - Wert in Zwischenspeicher laden");
        System.out.println("l - alten Wert aus Zwischenspeicher laden");
        String wahl = eingabe.next();

    switch (wahl){
        case "1":Rechner.weiterrechnen();
            break;
        case "2":
            Rechner.rechner();
            break;
        case "3":
            Rechner.startrechner();
            break;
        case "4":
            Main.main(null);
            break;
        case "a":
            System.out.println("Es befindet sich: " + Main.speichern + " im Speicher");
            Rechner.nachergebnis();
            break;
        case "d":
            Main.speichern = 0;
            System.out.println("Speicher geloescht. Es befindet sich: " + Main.speichern + " im Speicher\n");
            Rechner.nachergebnis();
            break;
        case "s":
             Main.speichern = Main.speicher_alt;
            System.out.println("Wert " + Main.speichern + "Wurde in den Zwischenspeicher geladen\n");
            Rechner.nachergebnis();
            break;
        case "l":
            Main.speicher_alt = Main.speichern;
            System.out.println("Wert " + Main.speicher_alt + "Wurde aus Zwischenspeicher nach Speicher geladen\n");
            System.out.println("Es kann mit dem alten Wert weitergerechnet werden.");
            Rechner.nachergebnis();
            break;
        }

Der Part mit dem speichern des Werts in der Variable Main.speicher_alt funktioniert leider nicht.
Die Variablen Speichern und speicher_alt wurden folgendermaßen implementiert:

public static double speichern;
    public static double speicher_alt;

 

[mihe7]

Der Part mit dem speichern des Werts in der Variable Main.speicher_alt funktioniert leider nicht.

Wie ich oben bereits angemerkt habe, legst Du nichts in speicher_alt ab sondern in speichern. Die Anweisung

Main.speichern = Main.speicher_alt;

kopiert den Wert, der sich aktuell in speicher_alt befindet, nach speichern. Das wäre, wenn ich mir den anderen Code ansehe, das Laden und nicht das Speichern. Das Speichern würde umgekehrt aussehen

Main.speicher_alt = Main.speichern;

 

[Alex_99]

@mihe7 Hat tatsächlich funktioniert.
Vielen Dank! 🙂

welch ein blöder Fehler..

 

[mihe7]

So etwas kann man zu einem gewissen Grad auch durch eine bessere Benennung der Variablen vermeiden: statt speichern (ein Verb) könnte man speicher und statt speicher_alt einfach zwischenspeicher verwenden. Dann würde dort stehen

Main.zwischenspeicher = Main.speicher;

und man muss nicht lange überlegen, wofür speicher_alt/speicher stehen.