update klassen und methoden

klassen&methoden.md

@@ -4,7 +4,7 @@
 
 
 Klassen in Groovy werden ähnlich wie in Java definiert, jedoch mit einigen
-syntaktischen Erleichterungen
+syntaktischen Erleichterungen: mit dem class-Schlüsselwort, ohne Semikolon
 
 Beispiel
   ```
@@ -14,6 +14,80 @@ Beispiel
 }
   ```
   
+  
+### 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
@@ -24,7 +98,6 @@ generiert automatisch Getter- und Setter-Methoden (wie in Ruby)
 Person person = new Person()
 person.name = "John"
 person.age = 30
-person.age = 30
 println person.name
 //John
 ```
@@ -63,32 +136,9 @@ static void(args) {
 }
 }
 ```
-  
-### 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
@@ -127,20 +177,24 @@ sum(5,2)
 ### Instanzmethoden
 
 Methoden können Instanzmethoden sein und auf Instanzvariablen zugreifen.
-```
-class Method {
 
- static void main(args) {
+```
-  Method myFunc = new Method()
+class Person {
-  myFunc.myMethod()
+    String name
+    int age
+
+    // Instanzmethode, um die Person vorzustellen
+    def introduce() {
+        println("Hello, my name is ${name} and I am ${age} years old.")
+    }
 }
 
-def myMethod() {
+Person person = new Person(name: 'Alice', age: 30)
-  println("I am inside my method")
+person.introduce()
-}
+// Hello, my name is Alice and I am 30 years old.
-}
 ```
 
+
 ### Statische Methoden
 ```
 class MathUtils {
@@ -164,10 +218,14 @@ In diesem Beispiel wird die Methode sayHello zur Klasse DynamicExample hinzugef
 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 zur Laufzeit
+// Hinzufügen einer Methode(=closure) zur Laufzeit
 DynamicExample.metaClass.sayHello = { -> println "Hello, World!" }
 
 def example = new DynamicExample()
@@ -176,8 +234,8 @@ example.sayHello()
 
 ### Expando
 
-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
+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
 ```
@@ -196,7 +254,8 @@ 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.
+Methodenparameter können Standdardwerte haben (wie in Ruby). Diese werden eingesetzt, falls beim Aufruf keine Parameter
+gesetzt werden.
 
 Beispiel 1
 ```
@@ -216,6 +275,7 @@ def sum(int a=10, int b=3) {
 }
 
 sum()
+// Sum is 13
 ```
 
 
@@ -225,7 +285,7 @@ Closures können auf Variablen aus ihrem umgebenden Gültigkeitsbereich zugreife
 „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 abgegeben, durch Kommas getrennt.
+optional und werden, sofern angegeben, durch Kommas getrennt.
 
 1. Parameter
   ```
@@ -316,8 +376,10 @@ Im Gegensatz zu einer regulären Groovy-Methode:
 
 ### Methodenverkettung
 
-Durch das Rückgeben von this kann man Methodenaufrufe verketten.
+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
   ```
@@ -336,9 +398,14 @@ class FluentPerson {
     }
 }
 
-def person = new FluentPerson().setName("John").setAge(30)
+// 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)