diff --git a/README.md b/README.md index 357c73d..18db54b 100644 --- a/README.md +++ b/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 + diff --git a/img/test.groovy b/img/test.groovy deleted file mode 100644 index 2e22d83..0000000 --- a/img/test.groovy +++ /dev/null @@ -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 - } - -} \ No newline at end of file diff --git a/live/bedingte_op.md b/live/bedingte_op.md new file mode 100644 index 0000000..5e981b6 --- /dev/null +++ b/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) +```` \ No newline at end of file diff --git a/live/bedingungen.md b/live/bedingungen.md new file mode 100644 index 0000000..57d3316 --- /dev/null +++ b/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) +```` + diff --git a/live/klassen.md b/live/klassen.md new file mode 100644 index 0000000..0f6d28e --- /dev/null +++ b/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._ \ No newline at end of file diff --git a/live/operatoren_ass.md b/live/operatoren_ass.md new file mode 100644 index 0000000..abfc592 --- /dev/null +++ b/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. + diff --git a/live/recap.md b/live/recap.md new file mode 100644 index 0000000..a371cd6 --- /dev/null +++ b/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 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}"); +``` \ No newline at end of file diff --git a/live/schleifen.md b/live/schleifen.md new file mode 100644 index 0000000..6d90d78 --- /dev/null +++ b/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!" +``` + diff --git a/live/solutions/bedingte_op.groovy b/live/solutions/bedingte_op.groovy new file mode 100644 index 0000000..d920ec0 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/live/solutions/bedingungen.groovy b/live/solutions/bedingungen.groovy new file mode 100644 index 0000000..6ec319c --- /dev/null +++ b/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 list) { + def counter = 0 + + if (list.size() == 0) { + return "Die übergebene Liste ist leer!" + } + for(i in 0.. person.alter > 17} +def erwachsenePersonen = personen.findAll(volljaehrig) + +def nameInGrossbuchstaben = { person -> person.name.toUpperCase() } +def ergebnis = erwachsenePersonen.collect(nameInGrossbuchstaben) + +println ergebnis diff --git a/live/solutions/operatoren.groovy b/live/solutions/operatoren.groovy new file mode 100644 index 0000000..87f5353 --- /dev/null +++ b/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] diff --git a/live/solutions/schleifen.groovy b/live/solutions/schleifen.groovy new file mode 100644 index 0000000..b161298 --- /dev/null +++ b/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() +} \ No newline at end of file diff --git a/Bedingungen.md b/skript/Bedingungen.md similarity index 100% rename from Bedingungen.md rename to skript/Bedingungen.md diff --git a/Datenstrukturen.md b/skript/Datenstrukturen.md similarity index 100% rename from Datenstrukturen.md rename to skript/Datenstrukturen.md diff --git a/notizen.md b/skript/notizen.md similarity index 100% rename from notizen.md rename to skript/notizen.md diff --git a/praesentation.pdf b/skript/praesentation.pdf similarity index 100% rename from praesentation.pdf rename to skript/praesentation.pdf diff --git a/praesentation.pptx b/skript/praesentation.pptx similarity index 100% rename from praesentation.pptx rename to skript/praesentation.pptx