From f041e3f860703e0bd8d2d4a9b80b8eadf5360e95 Mon Sep 17 00:00:00 2001 From: yuhtng12 Date: Wed, 2 Apr 2025 17:56:25 +0200 Subject: [PATCH 1/5] toggle negative sign (Teilaufgabe 1) --- .../java/htw/berlin/prog2/ha1/CalculatorTest.java | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java index ddff0daf..a6f6f46d 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -90,5 +90,18 @@ void testMultipleDecimalDots() { //TODO hier weitere Tests erstellen + @Test + @DisplayName("should toggle negative sign correctly") + void testToggleNegative() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(5); + calc.pressNegativeKey(); // -5 + assertEquals("-5", calc.readScreen()); + + calc.pressNegativeKey(); // zurück zu 5 + assertEquals("5", calc.readScreen()); + } + } From 76d329770800c097128eaa16461eccd2609f5d5e Mon Sep 17 00:00:00 2001 From: yuhtng12 Date: Wed, 2 Apr 2025 17:57:20 +0200 Subject: [PATCH 2/5] ClearKeyClearsOnlyScreen (Teilaufgabe 2) --- .../java/htw/berlin/prog2/ha1/CalculatorTest.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java index a6f6f46d..23a61d17 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -102,6 +102,20 @@ void testToggleNegative() { calc.pressNegativeKey(); // zurück zu 5 assertEquals("5", calc.readScreen()); } + @Test + @DisplayName("should clear only screen on first clear press, not memory") + void testClearKeyClearsOnlyScreen() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(8); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(3); + calc.pressClearKey(); // sollte nur Bildschirm zurücksetzen + calc.pressDigitKey(2); + calc.pressEqualsKey(); + + assertEquals("10", calc.readScreen()); // 8 + 2 + } } From 8ad68e85d84aae7f83c2af366236d273079cb999 Mon Sep 17 00:00:00 2001 From: yuhtng12 Date: Wed, 2 Apr 2025 17:57:53 +0200 Subject: [PATCH 3/5] TestRepeatedEquals (Teilaufgabe 2) --- .../java/htw/berlin/prog2/ha1/CalculatorTest.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java index 23a61d17..ad96ca9d 100644 --- a/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java +++ b/app/src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java @@ -116,6 +116,20 @@ void testClearKeyClearsOnlyScreen() { assertEquals("10", calc.readScreen()); // 8 + 2 } + @Test + @DisplayName("should repeat last operation when equals is pressed multiple times") + void testRepeatedEquals() { + Calculator calc = new Calculator(); + + calc.pressDigitKey(2); + calc.pressBinaryOperationKey("+"); + calc.pressDigitKey(3); + calc.pressEqualsKey(); // → 5 + calc.pressEqualsKey(); // → 8 + calc.pressEqualsKey(); // → 11 + + assertEquals("11", calc.readScreen()); + } } From f6a9036cfb6d3de32f8156d2d1d3381c059cc49a Mon Sep 17 00:00:00 2001 From: yuhtng12 Date: Wed, 2 Apr 2025 17:59:05 +0200 Subject: [PATCH 4/5] bugfixes (Teilaufgabe 3) --- .../java/htw/berlin/prog2/ha1/Calculator.java | 71 ++++++++++--------- 1 file changed, 37 insertions(+), 34 deletions(-) diff --git a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java index 84c04f21..01ba78b2 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -11,9 +11,12 @@ public class Calculator { private String screen = "0"; private double latestValue; - private String latestOperation = ""; + private double lastSecondOperand = 0.0; + private boolean justCalculated = false; + private boolean screenWasClearedOnce = false; + /** * @return den aktuellen Bildschirminhalt als String */ @@ -22,8 +25,7 @@ public String readScreen() { } /** - * Empfängt den Wert einer gedrückten Zifferntaste. Da man nur eine Taste auf einmal - * drücken kann muss der Wert positiv und einstellig sein und zwischen 0 und 9 liegen. + * Empfängt den Wert einer gedrückten Zifferntaste. * Führt in jedem Fall dazu, dass die gerade gedrückte Ziffer auf dem Bildschirm angezeigt * oder rechts an die zuvor gedrückte Ziffer angehängt angezeigt wird. * @param digit Die Ziffer, deren Taste gedrückt wurde @@ -34,6 +36,7 @@ public void pressDigitKey(int digit) { if(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = ""; screen = screen + digit; + justCalculated = false; } /** @@ -43,32 +46,33 @@ public void pressDigitKey(int digit) { * Wird daraufhin noch einmal die Taste gedrückt, dann werden auch zwischengespeicherte * Werte sowie der aktuelle Operationsmodus zurückgesetzt, so dass der Rechner wieder * im Ursprungszustand ist. + * Der Rechner merkt sich, ob der Bildschirm bereits gelöscht wurde, um beim zweiten Drücken + * auch die zwischengespeicherten Werte und Operationen zurückzusetzen. */ public void pressClearKey() { - screen = "0"; - latestOperation = ""; - latestValue = 0.0; + if (!screenWasClearedOnce) { + screen = "0"; + screenWasClearedOnce = true; + } else { + screen = "0"; + latestOperation = ""; + latestValue = 0.0; + screenWasClearedOnce = false; + } } /** - * Empfängt den Wert einer gedrückten binären Operationstaste, also eine der vier Operationen - * Addition, Substraktion, Division, oder Multiplikation, welche zwei Operanden benötigen. - * Beim ersten Drücken der Taste wird der Bildschirminhalt nicht verändert, sondern nur der - * Rechner in den passenden Operationsmodus versetzt. - * Beim zweiten Drücken nach Eingabe einer weiteren Zahl wird direkt des aktuelle Zwischenergebnis - * auf dem Bildschirm angezeigt. Falls hierbei eine Division durch Null auftritt, wird "Error" angezeigt. + * Empfängt den Wert einer gedrückten binären Operationstaste. * @param operation "+" für Addition, "-" für Substraktion, "x" für Multiplikation, "/" für Division */ - public void pressBinaryOperationKey(String operation) { + public void pressBinaryOperationKey(String operation) { latestValue = Double.parseDouble(screen); latestOperation = operation; + justCalculated = false; } /** - * Empfängt den Wert einer gedrückten unären Operationstaste, also eine der drei Operationen - * Quadratwurzel, Prozent, Inversion, welche nur einen Operanden benötigen. - * Beim Drücken der Taste wird direkt die Operation auf den aktuellen Zahlenwert angewendet und - * der Bildschirminhalt mit dem Ergebnis aktualisiert. + * Empfängt den Wert einer gedrückten unären Operationstaste. * @param operation "√" für Quadratwurzel, "%" für Prozent, "1/x" für Inversion */ public void pressUnaryOperationKey(String operation) { @@ -83,15 +87,11 @@ public void pressUnaryOperationKey(String operation) { screen = Double.toString(result); if(screen.equals("NaN")) screen = "Error"; if(screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10); - + justCalculated = true; } /** - * Empfängt den Befehl der gedrückten Dezimaltrennzeichentaste, im Englischen üblicherweise "." - * Fügt beim ersten Mal Drücken dem aktuellen Bildschirminhalt das Trennzeichen auf der rechten - * Seite hinzu und aktualisiert den Bildschirm. Daraufhin eingegebene Zahlen werden rechts vom - * Trennzeichen angegeben und daher als Dezimalziffern interpretiert. - * Beim zweimaligem Drücken, oder wenn bereits ein Trennzeichen angezeigt wird, passiert nichts. + * Empfängt den Befehl der gedrückten Dezimaltrennzeichentaste, z. B. ".". */ public void pressDotKey() { if(!screen.contains(".")) screen = screen + "."; @@ -99,10 +99,6 @@ public void pressDotKey() { /** * Empfängt den Befehl der gedrückten Vorzeichenumkehrstaste ("+/-"). - * Zeigt der Bildschirm einen positiven Wert an, so wird ein "-" links angehängt, der Bildschirm - * aktualisiert und die Inhalt fortan als negativ interpretiert. - * Zeigt der Bildschirm bereits einen negativen Wert mit führendem Minus an, dann wird dieses - * entfernt und der Inhalt fortan als positiv interpretiert. */ public void pressNegativeKey() { screen = screen.startsWith("-") ? screen.substring(1) : "-" + screen; @@ -110,24 +106,31 @@ public void pressNegativeKey() { /** * Empfängt den Befehl der gedrückten "="-Taste. - * Wurde zuvor keine Operationstaste gedrückt, passiert nichts. - * Wurde zuvor eine binäre Operationstaste gedrückt und zwei Operanden eingegeben, wird das - * Ergebnis der Operation angezeigt. Falls hierbei eine Division durch Null auftritt, wird "Error" angezeigt. * Wird die Taste weitere Male gedrückt (ohne andere Tasten dazwischen), so wird die letzte * Operation (ggf. inklusive letztem Operand) erneut auf den aktuellen Bildschirminhalt angewandt * und das Ergebnis direkt angezeigt. */ public void pressEqualsKey() { + double current = Double.parseDouble(screen); + + if (!justCalculated) { + lastSecondOperand = current; + } + var result = switch(latestOperation) { - case "+" -> latestValue + Double.parseDouble(screen); - case "-" -> latestValue - Double.parseDouble(screen); - case "x" -> latestValue * Double.parseDouble(screen); - case "/" -> latestValue / Double.parseDouble(screen); + case "+" -> latestValue + lastSecondOperand; + case "-" -> latestValue - lastSecondOperand; + case "x" -> latestValue * lastSecondOperand; + case "/" -> lastSecondOperand == 0 ? Double.POSITIVE_INFINITY : latestValue / lastSecondOperand; default -> throw new IllegalArgumentException(); }; + screen = Double.toString(result); if(screen.equals("Infinity")) screen = "Error"; if(screen.endsWith(".0")) screen = screen.substring(0,screen.length()-2); if(screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10); + + latestValue = result; + justCalculated = true; } } From 0c11b3a89212985291dadb5179d77b771e4dcc14 Mon Sep 17 00:00:00 2001 From: yuhtng12 Date: Thu, 17 Apr 2025 16:21:57 +0200 Subject: [PATCH 5/5] Bugfixes --- README.md | 2 +- .../java/htw/berlin/prog2/ha1/Calculator.java | 71 +++++++++---------- 2 files changed, 35 insertions(+), 38 deletions(-) diff --git a/README.md b/README.md index bba2d811..5288e85e 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# Hausaufgabe 1 + # Hausaufgabe 1 Deadline für Abgabe per Pull Request: 28.04.2024 23:59 Uhr. Außerdem ist zusätzlich eine persönliche Abnahme in der von Ihnen belegten Übungsgruppe notwendig, um zu bestehen. Bei unentschuldigtem Fehlen in der auf die Deadline folgenden Übung, wird die Hausaufgabe als nicht bestanden bewertet. diff --git a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java index 01ba78b2..84c04f21 100644 --- a/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java +++ b/app/src/main/java/htw/berlin/prog2/ha1/Calculator.java @@ -11,11 +11,8 @@ public class Calculator { private String screen = "0"; private double latestValue; - private String latestOperation = ""; - private double lastSecondOperand = 0.0; - private boolean justCalculated = false; - private boolean screenWasClearedOnce = false; + private String latestOperation = ""; /** * @return den aktuellen Bildschirminhalt als String @@ -25,7 +22,8 @@ public String readScreen() { } /** - * Empfängt den Wert einer gedrückten Zifferntaste. + * Empfängt den Wert einer gedrückten Zifferntaste. Da man nur eine Taste auf einmal + * drücken kann muss der Wert positiv und einstellig sein und zwischen 0 und 9 liegen. * Führt in jedem Fall dazu, dass die gerade gedrückte Ziffer auf dem Bildschirm angezeigt * oder rechts an die zuvor gedrückte Ziffer angehängt angezeigt wird. * @param digit Die Ziffer, deren Taste gedrückt wurde @@ -36,7 +34,6 @@ public void pressDigitKey(int digit) { if(screen.equals("0") || latestValue == Double.parseDouble(screen)) screen = ""; screen = screen + digit; - justCalculated = false; } /** @@ -46,33 +43,32 @@ public void pressDigitKey(int digit) { * Wird daraufhin noch einmal die Taste gedrückt, dann werden auch zwischengespeicherte * Werte sowie der aktuelle Operationsmodus zurückgesetzt, so dass der Rechner wieder * im Ursprungszustand ist. - * Der Rechner merkt sich, ob der Bildschirm bereits gelöscht wurde, um beim zweiten Drücken - * auch die zwischengespeicherten Werte und Operationen zurückzusetzen. */ public void pressClearKey() { - if (!screenWasClearedOnce) { - screen = "0"; - screenWasClearedOnce = true; - } else { - screen = "0"; - latestOperation = ""; - latestValue = 0.0; - screenWasClearedOnce = false; - } + screen = "0"; + latestOperation = ""; + latestValue = 0.0; } /** - * Empfängt den Wert einer gedrückten binären Operationstaste. + * Empfängt den Wert einer gedrückten binären Operationstaste, also eine der vier Operationen + * Addition, Substraktion, Division, oder Multiplikation, welche zwei Operanden benötigen. + * Beim ersten Drücken der Taste wird der Bildschirminhalt nicht verändert, sondern nur der + * Rechner in den passenden Operationsmodus versetzt. + * Beim zweiten Drücken nach Eingabe einer weiteren Zahl wird direkt des aktuelle Zwischenergebnis + * auf dem Bildschirm angezeigt. Falls hierbei eine Division durch Null auftritt, wird "Error" angezeigt. * @param operation "+" für Addition, "-" für Substraktion, "x" für Multiplikation, "/" für Division */ - public void pressBinaryOperationKey(String operation) { + public void pressBinaryOperationKey(String operation) { latestValue = Double.parseDouble(screen); latestOperation = operation; - justCalculated = false; } /** - * Empfängt den Wert einer gedrückten unären Operationstaste. + * Empfängt den Wert einer gedrückten unären Operationstaste, also eine der drei Operationen + * Quadratwurzel, Prozent, Inversion, welche nur einen Operanden benötigen. + * Beim Drücken der Taste wird direkt die Operation auf den aktuellen Zahlenwert angewendet und + * der Bildschirminhalt mit dem Ergebnis aktualisiert. * @param operation "√" für Quadratwurzel, "%" für Prozent, "1/x" für Inversion */ public void pressUnaryOperationKey(String operation) { @@ -87,11 +83,15 @@ public void pressUnaryOperationKey(String operation) { screen = Double.toString(result); if(screen.equals("NaN")) screen = "Error"; if(screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10); - justCalculated = true; + } /** - * Empfängt den Befehl der gedrückten Dezimaltrennzeichentaste, z. B. ".". + * Empfängt den Befehl der gedrückten Dezimaltrennzeichentaste, im Englischen üblicherweise "." + * Fügt beim ersten Mal Drücken dem aktuellen Bildschirminhalt das Trennzeichen auf der rechten + * Seite hinzu und aktualisiert den Bildschirm. Daraufhin eingegebene Zahlen werden rechts vom + * Trennzeichen angegeben und daher als Dezimalziffern interpretiert. + * Beim zweimaligem Drücken, oder wenn bereits ein Trennzeichen angezeigt wird, passiert nichts. */ public void pressDotKey() { if(!screen.contains(".")) screen = screen + "."; @@ -99,6 +99,10 @@ public void pressDotKey() { /** * Empfängt den Befehl der gedrückten Vorzeichenumkehrstaste ("+/-"). + * Zeigt der Bildschirm einen positiven Wert an, so wird ein "-" links angehängt, der Bildschirm + * aktualisiert und die Inhalt fortan als negativ interpretiert. + * Zeigt der Bildschirm bereits einen negativen Wert mit führendem Minus an, dann wird dieses + * entfernt und der Inhalt fortan als positiv interpretiert. */ public void pressNegativeKey() { screen = screen.startsWith("-") ? screen.substring(1) : "-" + screen; @@ -106,31 +110,24 @@ public void pressNegativeKey() { /** * Empfängt den Befehl der gedrückten "="-Taste. + * Wurde zuvor keine Operationstaste gedrückt, passiert nichts. + * Wurde zuvor eine binäre Operationstaste gedrückt und zwei Operanden eingegeben, wird das + * Ergebnis der Operation angezeigt. Falls hierbei eine Division durch Null auftritt, wird "Error" angezeigt. * Wird die Taste weitere Male gedrückt (ohne andere Tasten dazwischen), so wird die letzte * Operation (ggf. inklusive letztem Operand) erneut auf den aktuellen Bildschirminhalt angewandt * und das Ergebnis direkt angezeigt. */ public void pressEqualsKey() { - double current = Double.parseDouble(screen); - - if (!justCalculated) { - lastSecondOperand = current; - } - var result = switch(latestOperation) { - case "+" -> latestValue + lastSecondOperand; - case "-" -> latestValue - lastSecondOperand; - case "x" -> latestValue * lastSecondOperand; - case "/" -> lastSecondOperand == 0 ? Double.POSITIVE_INFINITY : latestValue / lastSecondOperand; + case "+" -> latestValue + Double.parseDouble(screen); + case "-" -> latestValue - Double.parseDouble(screen); + case "x" -> latestValue * Double.parseDouble(screen); + case "/" -> latestValue / Double.parseDouble(screen); default -> throw new IllegalArgumentException(); }; - screen = Double.toString(result); if(screen.equals("Infinity")) screen = "Error"; if(screen.endsWith(".0")) screen = screen.substring(0,screen.length()-2); if(screen.contains(".") && screen.length() > 11) screen = screen.substring(0, 10); - - latestValue = result; - justCalculated = true; } }