Live Übungen

README.md

@@ -19,8 +19,13 @@ Versuchen sie zuerst selbst auf die Lösung zu kommen und schauen sie sich dann
 
 | #   | Thema | Musterlösung |
 | --- | ----- | ------------ |
-| 1.  |       |              |
-| 2.  |       |              |
+| 1.  |[Operatoren][3]||
+| 2.  |[Schleifen und Bedingungen][4]||
+| 3.  |[Bedingungen][5]||
+| 4.  |[Klassen und Methoden][6]||
+| 5.  |[Bedingte Operatoren][7]||
+| 6.  |[Zusammenfassung][8]||
+
 
 ## Freiwillige Assignments:
 
@@ -38,3 +43,11 @@ Diese Aufgaben können sie verwenden, um sich **zu Hause** auf die Klausur vorzu
 
 [1]: https://groovy.apache.org/download.html
 [2]: https://www.jdoodle.com/execute-groovy-online
+
+[3]: ./live/operatoren_ass.md
+[4]: ./live/schleifen.md
+[5]: ./live//bedingungen.md
+[6]: ./live/klassen.md
+[7]: ./live/bedingte_op.md
+[8]: ./live/recap.md
+

img/test.groovy

@@ -1,14 +0,0 @@
-class StackSpec extends Specification {
-    def "Hinzufügen eines Elementes vergrößert die Größe des Stacks"() { // 1
-     
-        setup: "Eine neue Stack Instanz wird erstellt" // 2
-            def stack = new Stack()
-
-        when: // 3
-            stack.push(42);
-
-        then: //4
-            stack.size() == 1
-    }
-
-}

live/bedingte_op.md

@@ -0,0 +1,15 @@
+# Operatoren:
+
+Schreiben Sie eine Groovy-Methode **vergleich(a,b)**, die zwei Werte annimmt und diese vergleicht. Ist  einer von den Werten *null* soll ein Standardwert verwendet werden. Die Standartwerte sollen a=10 und b=20 sein Die Methode soll folgende Schritte ausführen:
+1. Um den Standardwert zu setzen soll der Elvis Operator verwendet werden.
+2. Der Vergleich der beiden Werte soll durch Einsatz des Spaceship-Operators implementiert werden.
+3. Es soll eine passende Ausgabe erzeugt werden.
+
+Rufen sie Ihre Methode mit folgenden Werten auf:
+````Groovy
+println vergleich(5, 15)
+println vergleich(null, 15)
+println vergleich(25, null)
+println vergleich(null, null)
+println vergleich(20, 20)
+````

live/bedingungen.md

@@ -0,0 +1,16 @@
+# Bedingungen:
+Gegeben sei folgende Listen:
+````Groovy
+def myList= [1,2,3,4,5,6,7,8,9,10]
+def emptyList = []
+````
+Schreiben Sie eine Methode check() welche die Anzahl der geraden Zahlen prüft und diese zurückgibt. Falls die Liste leer ist, soll folgendes zurückgegeben werden:
+````
+Die übergebene Liste ist leer!
+````
+Geben sie in jedem fall das Ergebnis auf der Konsole wie folgt aus:
+````Groovy
+println check(myList)
+println check(emptyList)
+````
+

live/klassen.md

@@ -0,0 +1,28 @@
+## Klassen und Closures:
+
+Gegeben sei eine simple Klasse **Person**, die als Attribute den Namen und das Alter einer Person erhält.
+
+```Groovy
+class Person{
+    def name
+    def alter
+}
+```
+
+Kopieren sie den obrigen Code, erstellen sie folgende drei Objekte dieser Klasse und packen sie diese in eine Liste:
+
+| Name  | Alter |
+| ----- | ----- |
+| Max   | 12    |
+| Karl  | 40    |
+| Laura | 23    |
+
+Erweitern sie die Klasse nicht, sondern nehmen Sie sie genauso wie sie ist. Wenden sie nun zwei Closures auf diese Liste an, um alle Personen, die volljährig sind in eine Liste zu schreiben. Die Namen sollen diesmal aber groß geschrieben sein. Ihre Ausgabe sollte also wie folgt aussehen:
+
+```Groovy
+[KARL, LAURA]
+```
+
+_Tipp: Sie werden sowohl die **findAll()**, als auch die **collect()** Methode auf Listen brauchen. Beide Methoden nehmen ein Closure als Argument an. \
+Die **findAll()** Methode prüft alle Elemente einer Liste auf eine Bedingung und gibt eine neue Liste aus mit allen Elementen, auf die die Bedingung zutrifft. \
+Die **collect()** Methode wird verwendet, um eine Liste oder eine Sammlung zu transformieren und gibt eine neue Liste mit den transformierten Elementen aus._

live/operatoren_ass.md

@@ -0,0 +1,9 @@
+#  Operatoren:
+
+Gegeben seien folgende zwei Listen: 
+```Groovy
+def words = ["Groovy", "ist", "cool"]
+def numbers = [1, 2, 3, 4, 5]
+```
+Verwenden Sie den Spread-Operator (*.), um eine zwei neue Listen zu erstellen. Die erste Liste soll die Längen aller Strings in *words* ethalten, während die zweite Liste eine Liste aller Zahlen aus *numbers* quardriert enthält.
+

live/recap.md

@@ -0,0 +1,91 @@
+# Zusammenfassung:
+
+Gegeben sei folgender Java-Code:
+
+```Java
+import java.util.ArrayList;
+import java.util.List;
+
+class Person {
+        String name;
+        int age;
+        public Person(String name, int age) {
+            this.name = name;
+            this.age = age;
+        }
+        
+        public String toString(){
+            return this.name + ", Alter: " + this.age;
+        }
+    }
+
+public class Main {
+    
+    public static void main(String[] args) {
+        List<Person> personen = new ArrayList<>();
+        personen.add(new Person("Alice", 20));
+        personen.add(new Person("Bob", 18));
+        personen.add(new Person("Charlie", 30));
+        personen.add(new Person("David", 15));
+        personen.add(new Person("Eve", 21));
+
+        for (Person p : personen) {
+            System.out.println(p);
+        }
+
+        int sum = 0;
+        for (int i = 1; i <= 10; i++) {
+            sum += i;
+        }
+        System.out.println("Sum of numbers from 1 to 10: " + sum);
+    }
+}
+```
+
+Der Code hat folgende Ausgabe:
+
+```
+Alice, Alter: 20
+Bob, Alter: 18
+Charlie, Alter: 30
+David, Alter: 15
+Eve, Alter: 21
+Sum of numbers from 1 to 10: 55
+```
+
+Wandeln sie den Java-Code so in Groovy-Code um, dass er die selbe Ausgabe erzeugt und folgende Groovy-Features benutzt:
+
+1. String Interpolation
+2. Ranges
+3. Variablendefinition mit **def**
+4. each-Schleifen und Closures
+5. Dynamische Listen
+6. for-in Schleifen
+7. Objekterstellung mit Default-Konstruktoren
+
+Versuchen sie sich beim implementieren so kurz wie möglich zu halten. Ziel dieser Aufgabe ist es, das gelernte zu wiederholen und zu zeigen wie kompakt Groovy-Code im Vergleich zu Java-Code sein kann.
+
+#### Lösung:
+
+```Groovy
+class Person{
+    def name
+    def age
+
+    def toString() {
+        "${name}, Alter: ${age}"
+    }
+}
+def personen = [new Person(name: "Alice", age: 20),
+new Person(name: "Bob", age: 18),
+new Person(name: "Charlie", age: 30),
+new Person(name: "David", age: 15),
+new Person(name: "Eve", age: 21)]
+
+personen.each{println it}
+def sum = 0
+for (i in 1..10) {
+    sum += i
+}
+println("Summe der Zahlen von 1-10: ${sum}");
+```

live/schleifen.md

@@ -0,0 +1,14 @@
+# Schleifen:
+
+Gegeben sei folgender String:
+
+```Groovy
+def str = "GGRROOOOVVYY  IISSTT  CCOOOOLL!!"
+```
+
+Benutzen sie eine for-in Schleife, um auf diesem String folgende Ausgabe zu erzeugen, definieren sie hierbei **keinen** neuen String.
+
+```Groovy
+"groovy ist cool!"
+```
+

live/solutions/bedingte_op.groovy

@@ -0,0 +1,23 @@
+def vergleich(a, b) {
+    def defaultA = 10
+    def defaultB = 20
+
+    def val1 = a ?: defaultA
+    def val2 = b ?: defaultB
+
+    def vergleich = val1 <=> val2
+
+    if (vergleich < 0) {
+        return "Erster Wert ist kleiner."
+    } else if (vergleich == 0) {
+        return "Beide Werte sind gleich."
+    } else {
+        return "Erster Wert ist größer."
+    }
+}
+
+println vergleich(5, 15)
+println vergleich(null, 15)
+println vergleich(25, null)
+println vergleich(null, null)
+println vergleich(20, 20)

live/solutions/bedingungen.groovy

@@ -0,0 +1,19 @@
+def myList = [1,2,3,4,5,6,7,8,9,10]
+def emptyList = []
+
+def check(List<Integer> list) {
+    def counter = 0
+
+    if (list.size() == 0) {
+        return "Die übergebene Liste ist leer!"
+    }
+    for(i in 0..<list.size()) {
+        if(list[i] % 2 == 0) {
+            counter++
+        }
+    }
+    return counter
+}
+
+println check(myList)
+println check(emptyList)

live/solutions/klassen.groovy

@@ -0,0 +1,14 @@
+class Person {
+    def name
+    def alter
+    }
+
+def personen = [new Person(name: "Max", alter: 12), new Person(name: "Karl", alter: 40), new Person(name: "Laura", alter: 23)]
+
+def volljaehrig = { person -> person.alter > 17}
+def erwachsenePersonen = personen.findAll(volljaehrig)
+
+def nameInGrossbuchstaben = { person -> person.name.toUpperCase() }
+def ergebnis = erwachsenePersonen.collect(nameInGrossbuchstaben)
+
+println ergebnis

live/solutions/operatoren.groovy

@@ -0,0 +1,6 @@
+def words = ["Groovy", "ist", "cool"]
+def lengths = words*.length()
+def squares = numbers*.multiply(numbers)
+
+println("Längen: $lengths")  // Erwartete Ausgabe: Längen: [6, 3, 4]
+println("Quadrate: $squares")  // Erwartete Ausgabe: Quadrate: [1, 4, 9, 16, 25]

live/solutions/schleifen.groovy

@@ -0,0 +1,9 @@
+Groovy
+def str = "GGRROOOOVVYY  IISSTT  CCOOOOLL!!"
+
+for(i in 0..str.length()) {
+    if (i % 2 == 0) {
+        continue
+    }
+    print str[i].toLowerCase()
+}