infos zu klassen und methoden

klassen&methoden.md

@@ -0,0 +1,292 @@
+## 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")
+  ```