groovy-lecture/aufgaben.md

# Aufgabe 1

### Aufgabenstellung:


Erstellen Sie eine Klasse Person, die eine Instanzvariable name vom Typ String und
eine Instanzvariable age vom Typ int hat. Implementieren Sie einen entsprechenden
Kostruktor, der die Instanzvariablen initialisiert.
Fügen Sie außerdem eine Methode introduce() hinzu,
die eine Vorstellung der Person auf der Konsole ausgibt. Erstellen Sie eine Instanz
der Klasse und rufen Sie die Methode introduce() auf.

### Lösung
```
class Person {
    String name
    int age

    Person(String name, int age) {
        this.name = name
        this.age = age
    }

    def introduce() {
        println("Hello, my name is ${name} and I am ${age} years old.")
    }
}

// Verwendung der Klasse Person
def person = new Person("Alice", 30)
person.introduce()
```

# Aufgabe 2
### Aufgabenstellung:

a) Erstelle eine Klasse Calculator, die Methoden für die Grundrechenoperationen
   Addition, Subtraktion, Multiplikation und Division bereitstellt. Implementiere die
   Methoden add(int a, int b), subtract(int a, int b), multiply(int a, int b) und
   divide(int a, int b). Die Methoden sollen die beiden übergebenen Zahlen
   entsprechend der Operation verarbeiten und das Ergebnis zurückgeben.

b) Erweitere die Klasse um eine Methode performOperation(int a, int b, Closure
   operation), die eine Closure als Parameter akzeptiert. Diese Closure soll eine
   Berechnung mit den beiden Zahlen durchführen und das Ergebnis zurückgeben. Zeige,
   wie man diese Methode verwendet, indem du verschiedene Closures übergibst.
   
### Lösung
```
class Calculator {
    def add(int a, int b) {
        return a + b
    }

    def subtract(int a, int b) {
        return a - b
    }

    def multiply(int a, int b) {
        return a * b
    }

    def divide(int a, int b) {
        if (b == 0) {
            println("Error: Division by zero!")
            return
        }
        return a / b
    }

    def performOperation(int a, int b, Closure operation) {
        return operation(a, b)
    }
}

// Verwendung der Klasse Calculator
def calc = new Calculator()

// Grundrechenoperationen
println("Addition: ${calc.add(5, 3)}")
println("Subtraction: ${calc.subtract(10, 7)}")
println("Multiplication: ${calc.multiply(4, 6)}")
println("Division: ${calc.divide(12, 4)}")

// Closures definieren
def addClosure = { int a, int b -> a + b }
def subtractClosure = { int a, int b -> a - b }
def multiplyClosure = { int a, int b -> a * b }
def divideClosure = { int a, int b -> 
    if (b == 0) {
        println("Error: Division by zero!")
        return
    }
    return a / b 
}

// Verwendung von performOperation mit Closures
println("Addition mit Closure: ${calc.performOperation(5, 3, addClosure)}")
println("Subtraction mit Closure: ${calc.performOperation(10, 7, subtractClosure)}")
println("Multiplication mit Closure: ${calc.performOperation(4, 6, multiplyClosure)}")
println("Division mit Closure: ${calc.performOperation(12, 4, divideClosure)}")
```

# Aufgabe 3
### Aufgabenstellung
Erstellen Sie eine Klasse EmployeeManager, die die Verwaltung von Mitarbeitern
ermöglicht. Die Klasse soll folgende Funktionen bieten:

1. Hinzufügen von Mitarbeitern mit Name und Gehalt.
2. Aktualisieren des Gehalts eines Mitarbeiters.
3. Entfernen eines Mitarbeiters.
4. Durchführen von Gehaltsanpassungen für alle Mitarbeiter basierend auf einer Closure, die eine Gehaltsanpassungslogik definiert.
5. Abrufen einer Liste von Mitarbeitern, die nach einem bestimmten Kriterium gefiltert wurden (basierend auf einer übergebenen Closure).

```
class Employee {
    String name
    double salary

    Employee(String name, double salary) {
        this.name = name
        this.salary = salary
    }

    String toString() {
        return "Name: ${name}, Salary: ${salary}"
    }
}

class EmployeeManager {
    List<Employee> employees = []

    void addEmployee(String name, double salary) {
        employees << new Employee(name, salary)
    }

    void updateSalary(String name, double newSalary) {
        employees.find { it.name == name }?.salary = newSalary
    }

    void removeEmployee(String name) {
        employees.removeAll { it.name == name }
    }

    void adjustSalaries(Closure adjustmentLogic) {
        employees.each { it.salary = adjustmentLogic(it.salary) }
    }

    List<Employee> filterEmployees(Closure criteria) {
        return employees.findAll(criteria)
    }
}

// Beispielnutzung der Klasse EmployeeManager
def manager = new EmployeeManager()

// Hinzufügen von Mitarbeitern
manager.addEmployee("Alice", 50000)
manager.addEmployee("Bob", 60000)
manager.addEmployee("Charlie", 55000)

// Aktualisieren des Gehalts eines Mitarbeiters
manager.updateSalary("Alice", 52000)

// Entfernen eines Mitarbeiters
manager.removeEmployee("Charlie")

// Durchführen von Gehaltsanpassungen für alle Mitarbeiter
manager.adjustSalaries { salary -> salary * 1.1 } // 10% Gehaltserhöhung

// Filtern von Mitarbeitern basierend auf einem Kriterium
def highEarners = manager.filterEmployees { it.salary > 55000 }

println("Alle Mitarbeiter:")
manager.employees.each { println it }

println("\nHigh Earners:")
highEarners.each { println it }
```