klassen und methoden aufgaben

aufgaben.md

@@ -0,0 +1,179 @@
+# 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 }
+```