groovy-lecture/klassen&methoden.md

## Klassen

- Definition einer Klasse
Klassen in Groovy werden ähnlich wie in Java definiert, jedoch mit einigen
syntaktischen Erleichterungen

Beispiel
  ```
  class Person {
    String name
    int age
}
  ```
  
  - 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
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")
}
}
```
  
  -Konstruktoren
  Groovy fügt automatisch einen Standardkonstruktor hinzu. Man kann auch
  benutzerdefinierte Konstruktoren definieren.
  ```
class Person {
  String name
  int age
  
  Person(String name, int age) {
      this.name = name
      this.age = age
    }
}
```

  -Standardkonstruktor mit Map
  Groovy bietet eine spezielle Initialisierungsform mit einer Map an
  ```
  Person person = new Person(name: 'John', age: 30)
  ```

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

 static void main(args) {
  Method myFunc = new Method()
  myFunc.myMethod()
}

def myMethod() {
  println("I am inside my method")
}
}
```

- 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
```
class DynamicExample {}

// Hinzufügen einer Methode zur Laufzeit
DynamicExample.metaClass.sayHello = { -> println "Hello, World!" }

def example = new DynamicExample()
example.sayHello()
```

- Expando
Ist eine spezielle Klassen 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-Parameterwerte
Methodenparameter können Standdardwerte haben(wie in Ruby)

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()
```


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

1. Parameter
  ```
def greet = { String name -> println "Hello, $name!" }
greet.call("John")
  ```

2. Referenzierung von Variablen und Rückgabewerte
  ```
def createCounter() {
    def count = 0
    return { ->
        count += 1
        return count
    }
}

def counter = createCounter()
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
  ```

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]
  ```

- Methodenverkettung
Durch das Rückgeben von this kann man Methodenaufrufe verketten.

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

def person = new FluentPerson().setName("John").setAge(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")
  ```