431 lines
9.9 KiB
Markdown
431 lines
9.9 KiB
Markdown
# 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.
|
|
Der Map-Konstruktor muss nicht explizit definiert werden (hier nur als Beispiel), da es ein eingebautes Standard-Feature von Groovy ist.
|
|
```
|
|
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, indem man $-Zeichen und optional eckige Klammern nutzt.
|
|
|
|
```
|
|
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")
|
|
```
|