abgabe erste HA Jannick Schott 0599300

src/main/java/htw/berlin/prog2/ha1/Calculator.java

@@ -59,7 +59,17 @@ public void pressClearKey() {
      * 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
      */
+    /**
+     * Setzt die binäre Operation (+, -, x, /) und speichert den aktuell sichtbaren Wert.
+     * Neu: akzeptiert auch "*" oder "×" als Alias für "x".
+     */
     public void pressBinaryOperationKey(String operation)  {
+        // --- NEU: Aliase auf "x" mappen, damit Multiplikation sicher erkannt wird ---
+        if ("*".equals(operation) || "×".equals(operation) || "X".equals(operation)) {
+            operation = "x";
+        }
+        // ---------------------------------------------------------------------------
+
         latestValue = Double.parseDouble(screen);
         latestOperation = operation;
     }
@@ -117,17 +127,73 @@ public void pressNegativeKey() {
      * Operation (ggf. inklusive letztem Operand) erneut auf den aktuellen Bildschirminhalt angewandt
      * und das Ergebnis direkt angezeigt.
      */
+    /**
+     * Empfängt den Befehl der gedrückten "="-Taste.
+     * Führt die zuvor gespeicherte Rechenoperation (z. B. +, -, x, /) mit dem aktuell eingegebenen
+     * Wert auf dem Bildschirm aus und zeigt das Ergebnis an.
+     *
+     * In dieser Version wurde die Art geändert, wie das Ergebnis in Textform (also auf dem Bildschirm)
+     * angezeigt wird:
+     *
+     * - Früher wurde das Ergebnis einfach mit Double.toString(result) umgewandelt.
+     *   Das führte dazu, dass sehr große oder sehr kleine Zahlen in wissenschaftlicher
+     *   Notation angezeigt wurden (z. B. "1.52399025E8" statt "152399025").
+     *
+     * - Jetzt wird das Ergebnis mit BigDecimal formatiert. Dadurch wird die Zahl immer
+     *   "normal" dargestellt, also so wie man sie auf einem Taschenrechner erwarten würde.
+     *
+     * - Außerdem wird jetzt überprüft, ob das Ergebnis "NaN" (keine Zahl) oder "Infinity"
+     *   (z. B. bei Division durch 0) ist. In diesen Fällen zeigt der Rechner "Error" an.
+     *
+     * - Abschließend wird die Anzeige auf 11 Zeichen begrenzt, damit sie auf den Bildschirm passt.
+     */
+    /**
+     * Führt die zuletzt gesetzte Operation mit dem aktuellen Bildschirmwert aus.
+     * Neu:
+     * - Division durch 0/NaN -> "Error"
+     * - Ergebnis auf 1 Nachkommastelle runden (HALF_UP), z. B. -4.6
+     * - Ausgabe ohne Exponentialschreibweise (toPlainString)
+     * - "-0" wird zu "0"
+     * - Länge auf 11 Zeichen begrenzt (Displaylimit)
+     */
     public void pressEqualsKey() {
-        var result = switch(latestOperation) {
+        // Wenn noch keine Operation gesetzt ist: nichts tun (verhindert Exception)
+        if (latestOperation == null || latestOperation.isEmpty()) return;
+
+        // Division durch 0 früh abfangen
+        if (latestOperation.equals("/") && Double.parseDouble(screen) == 0.0) {
+            screen = "Error";
+            return;
+        }
+
+        // Rechnen
+        double result = switch (latestOperation) {
             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);
+
+        // Fehlerfälle (z. B. 0/0) -> "Error"
+        if (Double.isNaN(result) || Double.isInfinite(result)) {
+            screen = "Error";
+            return;
+        }
+
+        // NEU: auf 1 Nachkommastelle runden (kaufmännisch)
+        java.math.BigDecimal rounded = java.math.BigDecimal
+                .valueOf(result)
+                .setScale(1, java.math.RoundingMode.HALF_UP);
+
+        // Lesbar ohne Exponentialschreibweise ausgeben
+        screen = rounded.stripTrailingZeros().toPlainString();
+
+        // "-0" vermeiden
+        if (screen.equals("-0")) screen = "0";
+
+        // Display-Limit einhalten
+        if (screen.length() > 11) screen = screen.substring(0, 11);
     }
+
 }

src/test/java/htw/berlin/prog2/ha1/CalculatorTest.java

@@ -88,7 +88,104 @@ void testMultipleDecimalDots() {
         assertEquals(expected, actual);
     }
 
+    @Test
+    @DisplayName("should display result after adding two positive multi-digit numbers")
+    void testAdditionWithNegatives() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(2);
+        calc.pressDigitKey(0);
+        calc.pressBinaryOperationKey("+");
+        calc.pressDigitKey(2);
+        calc.pressDigitKey(0);
+        calc.pressEqualsKey();
+
+        String expected = "40";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+
+    @Test
+    @DisplayName("should display result after dividing two positiv numbers")
+    void testPositiveDivision() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(2);
+        calc.pressBinaryOperationKey("/");
+        calc.pressDigitKey(2);
+        calc.pressEqualsKey();
+
+        String expected = "1";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+    @Test
+    @DisplayName("should display result after dividing two positive single-digit numbers")
+    void testDivision() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(6);
+        calc.pressBinaryOperationKey("/");
+        calc.pressDigitKey(2);
+        calc.pressEqualsKey();
+
+        String expected = "3";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+    @Test
+    @DisplayName("should display result after dividing two negativ multi digit numbers")
+    void testNegativDivisionWithHighNumbers() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(5);
+        calc.pressDigitKey(6);
+        calc.pressDigitKey(7);
+        calc.pressDigitKey(8);
+        calc.pressNegativeKey();
+        calc.pressBinaryOperationKey("/");
+        calc.pressDigitKey(1);
+        calc.pressDigitKey(2);
+        calc.pressDigitKey(3);
+        calc.pressDigitKey(4);
+        calc.pressEqualsKey();
+
+        String expected = "-4.6";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+    @Test
+    @DisplayName("should display result after multiplicating two positiv multi digit numbers")
+    void testMultiplicationWithHighNumbers() {
+        Calculator calc = new Calculator();
+
+        calc.pressDigitKey(1);
+        calc.pressDigitKey(2);
+        calc.pressDigitKey(3);
+        calc.pressDigitKey(4);
+        calc.pressDigitKey(5);
+        calc.pressBinaryOperationKey("x");
+        calc.pressDigitKey(1);
+        calc.pressDigitKey(2);
+        calc.pressDigitKey(3);
+        calc.pressDigitKey(4);
+        calc.pressDigitKey(5);
+        calc.pressEqualsKey();
+
+        String expected = "152399025";
+        String actual = calc.readScreen();
+
+        assertEquals(expected, actual);
+    }
+
+
+
+
+
 
     //TODO hier weitere Tests erstellen
 }
-