313 lines
7.2 KiB
Markdown
313 lines
7.2 KiB
Markdown
## GStrings vs Strings:
|
|
|
|
Erläutern sie kurz den Unterschied zwischen einem GString in Groovy und einem String und wie man einen mehrzeiligen GString definieren kann.
|
|
|
|
_Ein GString erlaubt es Variablen und Ausdrücke in einen String zu einzubetten, während ein String ein ganz herkömmlicher Java String ist, der keine Einbettugnen unterstützt. Mehrzeilige GStrings werden durch dreifache Anführungszeichen (""") definiert._
|
|
|
|
---
|
|
|
|
## Save Navigation Operator
|
|
|
|
Wie kann man in Groovy sicherstellen, dass in folgendem Codebeispiel keine NullPointerException auftritt? Sehen sie davon ab try-catch-Blöcke zu verwenden. Hier ist ein bestimmter Operator gefordert.
|
|
|
|
```Groovy
|
|
class Person {
|
|
String name
|
|
Address address
|
|
}
|
|
|
|
class Address {
|
|
String city
|
|
String street
|
|
}
|
|
|
|
def person = new Person(name: "Thomas Smits")
|
|
|
|
println(person.address.city)
|
|
```
|
|
|
|
_Indem man den safe navigation Operator, statt der herkömmlichen Navigation durch den "." Operator benutzt:_
|
|
|
|
```Groovy
|
|
println(person?.address?.city)
|
|
```
|
|
|
|
---
|
|
|
|
# Live Übung:
|
|
|
|
## Closure benutzen:
|
|
|
|
Schreiben sie ein Groovy-Skript, dass eine gegebene Liste von Zahlen (1-10) filtert und hierbei nur die geraden Zahlen behält. Geben sie das Ergebnis auf der Konsole aus. Verwenden sie für ihre Implementierung ein Closure und die findAll() Methode für Listen.
|
|
|
|
_Tipp: Die findAll() Methode nimmt ein Closure an und gibt eine neue Liste zurück, die alle Elemente enthält, für die die Bedingung des Closures gelten._
|
|
|
|
#### Lösung:
|
|
|
|
```Groovy
|
|
def zahlen = (1..10).toList()
|
|
def istGerade = { zahl -> zahl % 2 == 0 }
|
|
def geradeZahlen = zahlen.findAll(istGerade)
|
|
println geradeZahlen
|
|
```
|
|
|
|
---
|
|
|
|
## Klassen und Closures:
|
|
|
|
Schreiben sie eine simple Klasse **Person**, die als Attribute den Namen und das Alter einer Person erhält. Erstellen sie im nächsten Schritt folgende drei Objekte dieser Klasse und packen sie diese in eine Liste:
|
|
|
|
1. Max, 12 Jahre
|
|
2. Karl, 40 Jahre
|
|
3. Laura, 23 Jahre
|
|
|
|
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._
|
|
|
|
#### Lösung:
|
|
|
|
```Groovy
|
|
class Person {
|
|
String name
|
|
int alter
|
|
|
|
public Person(String name, int alter){
|
|
this.name = name
|
|
this.alter = alter
|
|
}
|
|
}
|
|
|
|
def personen = [new Person("Max", 12), new Person("Karl", 40), new Person("Laura", 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
|
|
|
|
```
|
|
|
|
---
|
|
|
|
## Spread Operator:
|
|
|
|
Gegeben sei folgender Groovy-Code:
|
|
|
|
```Groovy
|
|
class Person {
|
|
String name
|
|
int alter
|
|
|
|
public Person(String name, int alter){
|
|
this.name = name
|
|
this.alter = alter
|
|
}
|
|
|
|
def printIfAdult() {
|
|
if (this.alter > 17) {
|
|
println this.name + " ist volljährig."
|
|
}
|
|
}
|
|
}
|
|
|
|
def personen = [new Person("Max", 12), new Person("Karl", 40), new Person("Laura", 23), new Person("Ali", 15)]
|
|
|
|
for (person in personen) {
|
|
person.printIfAdult()
|
|
}
|
|
```
|
|
|
|
Schreiben sie den Code so um, sodass anstelle der for-in-Schleife ein passender Operator benutzt wird.
|
|
|
|
#### Lösung:
|
|
|
|
```Groovy
|
|
class Person {
|
|
String name
|
|
int alter
|
|
|
|
public Person(String name, int alter){
|
|
this.name = name
|
|
this.alter = alter
|
|
}
|
|
|
|
def printIfAdult() {
|
|
if (this.alter > 17) {
|
|
println this.name + " ist volljährig."
|
|
}
|
|
}
|
|
}
|
|
|
|
def personen = [new Person("Max", 12), new Person("Karl", 40), new Person("Laura", 23), new Person("Ali", 15)]
|
|
|
|
// Hier den Spread-Operator benutzen
|
|
personen*.printIfAdult()
|
|
```
|
|
|
|
---
|
|
|
|
## Ranges:
|
|
|
|
Schreiben sie ein kurzes Groovy-Skript, in dem sie eine Range von 1-25 erstellen. Zusätzlich soll die Range die Zahlen in dreier-Sprüngen enthalten:
|
|
-> (1,4,7,10...)
|
|
|
|
Erstellen sie als nächstes eine Range, die die Kleinbuchstaben a-z enthält.
|
|
|
|
Geben sie beide Ranges auf der Konsole aus.
|
|
|
|
_Tipp: Benutzen sie für die zweite Range zum ausgeben folgende Methode:_
|
|
|
|
```Groovy
|
|
// (Es wird später noch genauer hierauf eingegangen.)
|
|
letters.each{print it + " "}
|
|
```
|
|
|
|
#### Lösung:
|
|
|
|
```Groovy
|
|
def numbers = (1..25).step 3
|
|
def letters = 'a'..'z'
|
|
println numbers
|
|
letters.each{print it + " "}
|
|
```
|
|
|
|
---
|
|
|
|
## for-in-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!"
|
|
```
|
|
|
|
#### Lösung:
|
|
|
|
```Groovy
|
|
def str = "GGRROOOOVVYY IISSTT CCOOOOLL!!"
|
|
|
|
for(i in 0..str.length()) {
|
|
if (i % 2 == 0) {
|
|
continue
|
|
}
|
|
print str[i]
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## Schleifen umwandeln:
|
|
|
|
Gegeben sei folgender Groovy-Code:
|
|
|
|
```Groovy
|
|
def str = "GGRROOOOVVYY IISSTT CCOOOOLL!!"
|
|
|
|
for(int i = 0; i < str.length(); i++){
|
|
if (i % 2 == 0) {
|
|
continue
|
|
}
|
|
print str[i]
|
|
}
|
|
```
|
|
|
|
Schauen sie sich die Ausgabe an und wandeln sie den Code so um, dass eine while-Schleife benutzt wird, aber die gleiche Ausgabe erzeugt wird.
|
|
|
|
#### Lösung:
|
|
|
|
```Groovy
|
|
def str = "GGRROOOOVVYY IISSTT CCOOOOLL!!"
|
|
|
|
int i = 0
|
|
|
|
while (i < str.length()) {
|
|
if (i % 2 == 0) {
|
|
i++
|
|
continue
|
|
}
|
|
print str[i]
|
|
i++
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## Code umwandeln:
|
|
|
|
Gegeben sei folgender Java-Code:
|
|
|
|
```Java
|
|
import java.util.ArrayList;
|
|
import java.util.List;
|
|
|
|
public class Main {
|
|
public static void main(String[] args) {
|
|
List<String> names = new ArrayList<>();
|
|
names.add("Alice");
|
|
names.add("Bob");
|
|
names.add("Charlie");
|
|
names.add("David");
|
|
names.add("Eve");
|
|
|
|
for (String name : names) {
|
|
System.out.println(name);
|
|
}
|
|
|
|
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
|
|
Bob
|
|
Charlie
|
|
David
|
|
Eve
|
|
Summe der Zahlen von 1 bis 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
|
|
|
|
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
|
|
def names = ["Alice", "Bob", "Charlie", "David", "Eve"]
|
|
names.each{println it}
|
|
def sum = 0
|
|
for (i in 1..10) {
|
|
sum += i
|
|
}
|
|
println("Summe der Zahlen von 1 bis 10: ${sum}");
|
|
```
|