From 5faa5a166ce74979473c4114046b86e0d31ca8e4 Mon Sep 17 00:00:00 2001
From: ho <@>
Date: Fri, 12 May 2023 14:57:49 +0200
Subject: [PATCH] =?UTF-8?q?Mehr=20String-=C3=9Cbungen=20+=20Reihenfolge=20?=
 =?UTF-8?q?ge=C3=A4ndert?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ArrayExperimente.java     | 117 ++++++++++++++++++++++++++++----------
 ArrayExperimenteTest.java |  28 +++++++--
 2 files changed, 112 insertions(+), 33 deletions(-)

diff --git a/ArrayExperimente.java b/ArrayExperimente.java
index 09768e1..5d039fe 100644
--- a/ArrayExperimente.java
+++ b/ArrayExperimente.java
@@ -6,7 +6,8 @@
  * 
  * Du kannst deine Loesungen mit der beigefuegten Testklasse automatisch 
  * ueberpruefen
- *   - Klicke dazu im Hauptfenster auf Werkzeuge -> Testen -> Tests  starten
+ *   - Klicke mit der rechten Maustaste auf die ArrayExperimenteTest (grün) 
+ *     -> "Alles Testen" 
  *   - Sobald du glaubst, eine Funktion fertig programmiert zu haben, 
  *     startest du die Tests und ueberzeugst dich im Testergebnisfenster, 
  *     dass der Test fuer diese Funktion erfolgreich durchgelaufen ist.
@@ -21,16 +22,93 @@ public class ArrayExperimente
 
     /**
      * Gibt das uebergebene Array auf der Konsole aus.
-     * @param array, das ausgegeben werden soll.
+     * @param array, das Array, das ausgegeben werden soll.
      */
     public static void arrayAusgeben(int[] array)
     {
-        for(int i=0; i<array.length; i++)
+        for(int i=0; i<array.length; i++) // Durchläuft das ganze Array
         {
-            System.out.println(array[i]);
+            System.out.println(array[i]); // und gebe dein Eintrag an der Stelle i aus
         }
     }
+    
+    
+    /**
+     * Zum Ausprobieren: Erstellt ein neues int-Array und füllt alle Einträge mit 42
+     * anschließend wird das Array auf der Konsole ausgegeben
+     */
+    public static void zumAusprobieren()
+    {
+        //Erstellt ein neues int-Array
+        int[] meinArray = new int[10];
+        
+        //Gehe mit einer vor Schleife durch dass Array
+        for(int i=0; i<meinArray.length; i++)
+        {
+            //TODO: Hier musst du nurnoch den jeweiligen Wert mit 42 belegen
+        }
+        
+        //Gebe das Array auf der Konsole aus
+        arrayAusgeben(meinArray);
+    }
+    
+        /**
+     * Zum Ausprobieren: Wie eben, nur jetzt soll das Array mit den Werten
+     * 0, 1, 2, ... 9 belegt werden
+     */
+    public static void zumAusprobieren2()
+    {
+        //TODO:
+        //Erstelle ein neues Array und belege es mit den Einträgen 0 bis 9
+        //Du brauchst wieder eine for-Schleife
+        //Gebe anschließend das das Array auf der Konsole aus
+    }
+    
+    
+    
+    /**
+     * Der Funktion wird ein Array übergeben.
+     * Die Funktion erhoeht nun jeden Eintrag um eins.
+     * Es wird kein neues Array angelegt.
+     * @param array Zu manipulierendes Array. Es darf nicht leer sein.    
+     */
+    public static void addiereJeweilsEins(int[] array)
+    {
+        // TODO...
+        //Du brauchst wieder eine for-Schleife
+    }
+    
+    
+    
+    /**
+     * Die Funktion erhoeht im urspruenglichen Array jeden Eintrag um "zuschlag".
+     * Es wird kein neues Array angelegt.
+     * @param array Zu manipulierendes Array. Es darf nicht leer sein.    
+     * @param zuschlag diese Zahl wird zu jedem Arrayeintrag dazuaddiert.
+     */
+    public static void addiereJeweilsD(int[] array, int zuschlag)
+    {
+        // TODO...
+    }
+    
+    
+    
+    /**
+     * Ermittelt die Summe ueber alle Arrayelemente.
+     * @param array Array, das aufaddiert wird.
+     * @returns Summe aller Arrayelemente.
+     */
+    public static int summe(int[] array)
+    {
+        // TODO...
+        //Hinweis: Du benötigst eine Variable  
 
+        // das return steht hier nur, damit der Compiler nicht meckert:
+        return -32460;
+    }    
+
+    
+    
     /**
      * Ermittelt, ob ein Wert im Array vorkommt, d.h. ob
      * eines der Arrayelemente diesen Wert hat.
@@ -46,6 +124,8 @@ public class ArrayExperimente
         return false;
     }    
 
+    
+    
     /**
      * Ermittelt, an welchem Index im Array der Wert "gesucht" vorkommt.
      * @param gesucht Wert, nach dem im Array gesucht wird.
@@ -77,6 +157,8 @@ public class ArrayExperimente
         return -346;
     }
 
+    
+    
     /**
      * Ermittelt den Index des groessten im Array enthaltenen Elements.
      * @param array Array, in dem gesucht wird.
@@ -91,6 +173,8 @@ public class ArrayExperimente
 
     }
 
+    
+    
     /**
      * Ermittelt den Index des groessten im Array enthaltenen Elements. 
      * @param array Array, in dem gesucht wird.
@@ -107,31 +191,6 @@ public class ArrayExperimente
         return -3244786;
     }
 
-    /**
-     * Ermittelt die Summe ueber alle Arrayelemente.
-     * @param array Array, das aufaddiert wird.
-     * @returns Summe aller Arrayelemente.
-     */
-    public static int querSumme(int[] array)
-    {
-        // TODO...
-
-        // das return steht hier nur, damit der Compiler nicht meckert:
-        return -32460;
-    }    
-
-    /**
-     * Die Funktion erhoeht im urspruenglichen Array jeden Eintrag um "zuschlag".
-     * Es wird kein neues Array angelegt.
-     * @param array Zu manipulierendes Array. Es darf nicht leer sein.    
-     * @param zuschlag diese Zahl wird zu jedem Arrayeintrag dazuaddiert.
-     */
-    public static void addiereJeweilsD(int[] array, int zuschlag)
-    {
-        // TODO...
-    }
-
-    
 
     /**
      * Erstellt ein neues Array, in dem die Elemente des
diff --git a/ArrayExperimenteTest.java b/ArrayExperimenteTest.java
index 9e39250..a776ea0 100644
--- a/ArrayExperimenteTest.java
+++ b/ArrayExperimenteTest.java
@@ -107,23 +107,43 @@ public class ArrayExperimenteTest
     public void testquersumme()
     {
         int[] testArray = new int[] {1, -43, 3, 4, 13, 70, -41};
-        assertEquals(7, ArrayExperimente.querSumme(testArray));
+        assertEquals(7, ArrayExperimente.summe(testArray));
 
         testArray = new int[] {0, -43, -41};
-        assertEquals(-84, ArrayExperimente.querSumme(testArray));
+        assertEquals(-84, ArrayExperimente.summe(testArray));
 
         // einelementiges Array:
         testArray = new int[] {51};
-        assertEquals(51, ArrayExperimente.querSumme(testArray));
+        assertEquals(51, ArrayExperimente.summe(testArray));
     }
+    
+    @Test
+    public void testaddiereJeweilsEins()
+    {
+        int[] arrayVorher = new int[] {1, -43, 3, 4, 13, 70, -41};
+        int[] testArray   = new int[] {1, -43, 3, 4, 13, 70, -41};
 
+        int dazu = 1;
+        ArrayExperimente.addiereJeweilsD(testArray, dazu);
+
+        int idx = 0;
+        while(idx < testArray.length)
+        {
+            if( testArray[idx] != arrayVorher[idx] + dazu )
+            {
+                fail("Arrays unterscheiden sich an der Position " + idx + "!");
+            }
+            idx ++ ;
+        }
+    }
+    
     @Test
     public void testaddiereJeweilsD()
     {
         int[] arrayVorher = new int[] {1, -43, 3, 4, 13, 70, -41};
         int[] testArray   = new int[] {1, -43, 3, 4, 13, 70, -41};
 
-        int dazu = 1;
+        int dazu = 5;
         ArrayExperimente.addiereJeweilsD(testArray, dazu);
 
         int idx = 0;