update
parent
8364bf8671
commit
8b024af3f4
|
|
@ -0,0 +1 @@
|
|||
.DS_Store
|
||||
179
aufgaben.md
179
aufgaben.md
|
|
@ -1,179 +0,0 @@
|
|||
# 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 }
|
||||
```
|
||||
|
|
@ -1,429 +0,0 @@
|
|||
# Klassen
|
||||
|
||||
### Definition einer Klasse
|
||||
|
||||
|
||||
Klassen in Groovy werden ähnlich wie in Java definiert, jedoch mit einigen
|
||||
syntaktischen Erleichterungen: mit dem class-Schlüsselwort, ohne Semikolon
|
||||
|
||||
Beispiel
|
||||
```
|
||||
class Person {
|
||||
String name
|
||||
int age
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
### Konstruktoren
|
||||
|
||||
Groovy fügt automatisch einen Standardkonstruktor (="Default-Konstruktor") hinzu, wenn
|
||||
keine Konstruktoren explizit definiert sind. Dieser Standardkonstruktor initialisiert alle
|
||||
Eigenschaften der Klasse mit ihren Standardwerten.
|
||||
Man kann auch benutzerdefinierte Konstruktoren definieren oder die beiden Konstruktorarten
|
||||
auch gleichzeitig nutzen. Man spricht dabei von Konstruktorüberladung (auch wie in Java,
|
||||
C++, C#...)
|
||||
|
||||
```
|
||||
class Person {
|
||||
String name
|
||||
int age
|
||||
|
||||
//Default-Konstruktor
|
||||
def person = new Person()
|
||||
|
||||
//benutzerdefinierter Konstruktor
|
||||
Person(String name, int age) {
|
||||
this.name = name
|
||||
this.age = age
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
```
|
||||
class Person {
|
||||
String name
|
||||
int age
|
||||
|
||||
Person() {
|
||||
// Standardkonstruktor
|
||||
}
|
||||
|
||||
Person(String name, int age) {
|
||||
this.name = name
|
||||
this.age = age
|
||||
}
|
||||
}
|
||||
|
||||
def person1 = new Person()
|
||||
println(person1.name) // Ausgabe: null
|
||||
println(person1.age) // Ausgabe: 0
|
||||
|
||||
def person2 = new Person("Alice", 30)
|
||||
println(person2.name) // Ausgabe: Alice
|
||||
println(person2.age) // Ausgabe: 30
|
||||
```
|
||||
|
||||
|
||||
### Standardkonstruktor mit Map
|
||||
|
||||
Groovy bietet eine spezielle Initialisierungsform mit einer Map an. Dieser Konstruktor
|
||||
ermöglicht Objekte einfach und übersichtlich zu initialisieren, indem die Eigenschaften
|
||||
des Objekts direkt in Form von Schlüssel-Wert-Paaren in der Map angegeben werden.
|
||||
Groovy kümmert sich dann um die Zuordnung der Werte zu den entsprechenden Feldern der Klasse.
|
||||
```
|
||||
class Person {
|
||||
String name
|
||||
int age
|
||||
|
||||
// Map-Konstruktor
|
||||
Person(Map properties) {
|
||||
properties.each { key, value -> this."$key" = value }
|
||||
}
|
||||
}
|
||||
|
||||
Person person = new Person(name: 'John', age: 30)
|
||||
println(person.name) // Ausgabe: John
|
||||
println(person.age) // Ausgabe: 30
|
||||
```
|
||||
|
||||
|
||||
### Eigenschaften
|
||||
|
||||
Eigenschaften können direkt als Felder definiert werden. Groovy
|
||||
generiert automatisch Getter- und Setter-Methoden (wie in Ruby)
|
||||
|
||||
Beispiel
|
||||
```
|
||||
Person person = new Person()
|
||||
person.name = "John"
|
||||
person.age = 30
|
||||
println person.name
|
||||
//John
|
||||
```
|
||||
|
||||
|
||||
Getter und Setter können aber auch manuell überschrieben werden
|
||||
|
||||
Beispiel
|
||||
|
||||
```
|
||||
class Fruits {
|
||||
private String fruitName
|
||||
private String fruitColor
|
||||
|
||||
def setFruitName(String name) {
|
||||
fruitName = name
|
||||
}
|
||||
|
||||
def getFruitName() {
|
||||
return "The fruitname is $fruitName"
|
||||
}
|
||||
|
||||
def setFruitColor(String color) {
|
||||
fruitColor = color
|
||||
}
|
||||
|
||||
def getFruitColor(){
|
||||
return "The color is $fruitColor"
|
||||
}
|
||||
|
||||
static void(args) {
|
||||
//Instanz erstellen
|
||||
Fruits apple = new Fruits()
|
||||
apple.setFruitName("apple")
|
||||
apple.setFruitColor("red")
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
# Methoden
|
||||
|
||||
### Definition einer Methode
|
||||
|
||||
Methoden werden ähnlich wie in Java definiert, können aber optional einen Rückgabetyp
|
||||
haben
|
||||
```
|
||||
class Calculator {
|
||||
int add(int a, int b) {
|
||||
return a + b
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
In Groovy können Methoden direkt ohne Klasse und main-Methode definiert und aufgerufen
|
||||
werden.
|
||||
|
||||
|
||||
Beispiel 1
|
||||
```
|
||||
def printHello() {
|
||||
println "Hello..."
|
||||
}
|
||||
|
||||
printHello()
|
||||
|
||||
def sum(int a, int b) {
|
||||
println "Sum is "+(a+b)
|
||||
}
|
||||
|
||||
sum(5,2)
|
||||
//Hello...
|
||||
// 7
|
||||
```
|
||||
|
||||
### Instanzmethoden
|
||||
|
||||
Methoden können Instanzmethoden sein und auf Instanzvariablen zugreifen.
|
||||
|
||||
```
|
||||
class Person {
|
||||
String name
|
||||
int age
|
||||
|
||||
// Instanzmethode, um die Person vorzustellen
|
||||
def introduce() {
|
||||
println("Hello, my name is ${name} and I am ${age} years old.")
|
||||
}
|
||||
}
|
||||
|
||||
Person person = new Person(name: 'Alice', age: 30)
|
||||
person.introduce()
|
||||
// Hello, my name is Alice and I am 30 years old.
|
||||
```
|
||||
|
||||
|
||||
### Statische Methoden
|
||||
```
|
||||
class MathUtils {
|
||||
// Definition einer statischen Methode
|
||||
static int add(int a, int b) {
|
||||
return a + b
|
||||
}
|
||||
|
||||
static void main(String[] args) {
|
||||
// Aufruf der statischen Methode ohne Instanz der Klasse
|
||||
int result = MathUtils.add(5, 10)
|
||||
println("Sum is $result") // Ausgabe: Sum is 15
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### Dynamische Methoden
|
||||
|
||||
Groovy erlaubt es, Methoden zur Laufzeit hinzuzufügen.
|
||||
In diesem Beispiel wird die Methode sayHello zur Klasse DynamicExample hinzugefügt, nachdem
|
||||
die Klasse bereits definiert wurde
|
||||
|
||||
Beispiel
|
||||
|
||||
Groovy ermöglicht es, Methoden zur Laufzeit hinzuzufügen, was eine hohe Flexibilität bei der Gestaltung
|
||||
von Klassen und deren Verhalten bietet. Diese Fähigkeit ist Teil der dynamischen Natur von Groovy und
|
||||
wird durch die metaClass-Eigenschaft ermöglicht
|
||||
```
|
||||
class DynamicExample {}
|
||||
|
||||
// Hinzufügen einer Methode(=closure) zur Laufzeit
|
||||
DynamicExample.metaClass.sayHello = { -> println "Hello, World!" }
|
||||
|
||||
def example = new DynamicExample()
|
||||
example.sayHello()
|
||||
```
|
||||
|
||||
### Expando
|
||||
|
||||
Expando ist eine spezielle Klasse in Groovy, die ermöglicht, Objekten zur Laufzeit dynamisch Methoden und Eigenschaften
|
||||
hinzuzufügen. Dadurch ist die vorherige Deklaration der Felder in der Klasse nicht nötig
|
||||
|
||||
Beispiel
|
||||
```
|
||||
// Erstellen eines Expando-Objekts
|
||||
def expando = new Expando()
|
||||
|
||||
// Hinzufügen einer Eigenschaft 'name' und Zuweisung des Wertes "Groovy"
|
||||
expando.name = "Groovy"
|
||||
|
||||
// Hinzufügen einer Methode 'sayHello', die eine Nachricht ausgibt, die die Eigenschaft 'name' verwendet
|
||||
expando.sayHello = { -> println "Hello from $name" }
|
||||
|
||||
// Aufrufen der Methode 'sayHello', was die Nachricht "Hello from Groovy" ausgibt
|
||||
expando.sayHello() // Ausgabe: Hello from Groovy
|
||||
```
|
||||
|
||||
### Default-Parameter
|
||||
|
||||
Methodenparameter können Standdardwerte haben (wie in Ruby). Diese werden eingesetzt, falls beim Aufruf keine Parameter
|
||||
gesetzt werden.
|
||||
|
||||
Beispiel 1
|
||||
```
|
||||
class Greeter {
|
||||
void greet(String name = "World") {
|
||||
println "Hello, $name!"
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Ruft man die Methode ohne Parameter auf, werden die Default-Paramter eingesetzt
|
||||
|
||||
Beispiel 2
|
||||
```
|
||||
def sum(int a=10, int b=3) {
|
||||
println "Sum is "+(a+b)
|
||||
}
|
||||
|
||||
sum()
|
||||
// Sum is 13
|
||||
```
|
||||
|
||||
|
||||
### Closures
|
||||
|
||||
Closures können auf Variablen aus ihrem umgebenden Gültigkeitsbereich zugreifen und diese
|
||||
„einfangen“. Dadurch können sie auf Werte zugreifen, die zum Zeitpunkt ihrer Erstellung
|
||||
existierten.
|
||||
Closures enthalten Parameter, den Pfeil -> und den auszuführenden Code. Parameter sind
|
||||
optional und werden, sofern angegeben, durch Kommas getrennt.
|
||||
|
||||
1. Parameter
|
||||
```
|
||||
//closure takes one parameter - name - and prints it when invoked
|
||||
|
||||
def greet = { String name -> println "Hello, $name!" }
|
||||
greet.call("John")
|
||||
```
|
||||
|
||||
2. Referenzierung von Variablen und Rückgabewerte
|
||||
Dieses Beispiel zeigt, wie Closures auf Variablen im auf Variablen im umgebenden Kontext
|
||||
zugreifen und diese beibehalten können. Somit wird es Closures ermöglicht, Zustände
|
||||
zwischen verschiedenen Aufrufen beizubehalten.
|
||||
|
||||
|
||||
```
|
||||
def createCounter() {
|
||||
def count = 0 //lokale var
|
||||
return { ->
|
||||
count += 1
|
||||
return count
|
||||
}
|
||||
}
|
||||
|
||||
//Ergebnis bzw. closure wird counter zugewiesen
|
||||
def counter = createCounter()
|
||||
|
||||
//counter hat zugriff auf count *innerhalb des Kontexts*
|
||||
//in dem sie erstellt wurde
|
||||
|
||||
println(counter()) // Ausgabe: 1
|
||||
println(counter()) // Ausgabe: 2
|
||||
```
|
||||
|
||||
|
||||
3. Übergabe als Parameter
|
||||
```
|
||||
def performOperation(int x, Closure operation) {
|
||||
return operation(x)
|
||||
}
|
||||
|
||||
def closure = { y -> y * 2 }
|
||||
def result = performOperation(5, closure)
|
||||
println(result) // Ausgabe: 10
|
||||
```
|
||||
|
||||
### Wie ruft man eine Closure auf
|
||||
|
||||
Eine Closure kann sowohl als eine reguläre Methode als auch mit call aufrufen werden
|
||||
|
||||
```
|
||||
// Closure-Definition
|
||||
def greet = { name ->
|
||||
return "Hello, ${name}!"
|
||||
}
|
||||
|
||||
// Aufruf der Closure als reguläre Methode
|
||||
println(greet("Alice")) // Ausgabe: Hello, Alice!
|
||||
|
||||
// Aufruf der Closure mit call
|
||||
println(greet.call("Bob")) // Ausgabe: Hello, Bob!
|
||||
```
|
||||
|
||||
|
||||
Methoden können auch auf Maps und Listen angewendet werden, besonders nützlich mit Closures.
|
||||
|
||||
|
||||
```
|
||||
def myMap = [ 'subject': 'groovy', 'topic': 'closures']
|
||||
println myMap.each { it }
|
||||
|
||||
def myList = [1, 2, 3, 4, 5]
|
||||
println myList.find { item -> item == 3 } // 3
|
||||
println myList.findAll { item -> item > 3 } // [4, 5]
|
||||
println myList.any { item -> item > 5 } // false
|
||||
println myList.every { item -> item > 3 } // false
|
||||
println myList.collect { item -> item * 2 } // [2, 4, 6, 8, 10]
|
||||
```
|
||||
|
||||
Im Gegensatz zu einer regulären Groovy-Methode:
|
||||
|
||||
- Wir können eine Closure als Argument an eine Methode übergeben
|
||||
- Wir können eine Closure einer Variablen zuweisen und später ausführen, entweder als Methode oder mit call.
|
||||
- Groovy bestimmt den Rückgabewert der Closures zur Laufzeit.
|
||||
- Wir können Closures innerhalb einer Closure deklarieren und aufrufen.
|
||||
- Closures geben immer einen Wert zurück
|
||||
|
||||
|
||||
### Methodenverkettung
|
||||
|
||||
Methodenverkettung ermöglicht,dass Methodenaufrufe direkt nacheinander aufeinanderfolgen können, indem das Objekt
|
||||
selbst (normalerweise mit this) zurückgegeben wird.
|
||||
Dies ermöglicht eine flüssige und verständliche Art, Methoden aufzurufen und zu kombinieren, insbesondere wenn diese
|
||||
Methoden denselben oder ähnlichen Kontext haben. (wie in JS, )
|
||||
|
||||
Beispiel
|
||||
```
|
||||
class FluentPerson {
|
||||
String name
|
||||
int age
|
||||
|
||||
FluentPerson setName(String name) {
|
||||
this.name = name
|
||||
return this
|
||||
}
|
||||
|
||||
FluentPerson setAge(int age) {
|
||||
this.age = age
|
||||
return this
|
||||
}
|
||||
}
|
||||
|
||||
// Erstellen einer neuen FluentPerson-Instanz und Methodenverkettung
|
||||
def person = new FluentPerson()
|
||||
.setName("Alice")
|
||||
.setAge(30)
|
||||
|
||||
println "Name: ${person.name}, Age: ${person.age}" // Ausgabe: Name: Alice, Age: 30
|
||||
|
||||
```
|
||||
|
||||
|
||||
### Mixin(Misching)
|
||||
|
||||
Man kann Funktionalität zu Klassen hinzufügen, ohne Vererbung zu verwenden, indem man
|
||||
Mixins verwendet.
|
||||
|
||||
Beispiel
|
||||
```
|
||||
class ExtraMethods {
|
||||
String shout(String str) {
|
||||
return str.toUpperCase()
|
||||
}
|
||||
}
|
||||
|
||||
@Mixin(ExtraMethods)
|
||||
class MyClass {}
|
||||
|
||||
def myObject = new MyClass()
|
||||
println myObject.shout("hello")
|
||||
```
|
||||
Binary file not shown.
Binary file not shown.
Loading…
Reference in New Issue