groovy-lecture/ileyan/klausuraufgaben.md

## 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

#### Lösung: