From 2834cfe6e1a5f955d26a4c80406cfbe13b5c79da Mon Sep 17 00:00:00 2001
From: Yuliya Rudenko <3000014@stud.hs-mannheim.de>
Date: Wed, 22 May 2024 17:58:29 +0200
Subject: [PATCH] update

---
 klassen&methoden.md | 88 ++++++++++++++++++++++++++++++++++-----------
 1 file changed, 67 insertions(+), 21 deletions(-)

diff --git a/klassen&methoden.md b/klassen&methoden.md
index de47480..80831a4 100644
--- a/klassen&methoden.md
+++ b/klassen&methoden.md
@@ -1,6 +1,7 @@
-## Klassen
+# Klassen
+
+### Definition einer Klasse
 
-- Definition einer Klasse
 
 Klassen in Groovy werden ähnlich wie in Java definiert, jedoch mit einigen
 syntaktischen Erleichterungen
@@ -13,7 +14,7 @@ Beispiel
 }
   ```
   
-  - Eigenschaften
+### Eigenschaften
 
 Eigenschaften können direkt als Felder definiert werden. Groovy
 generiert automatisch Getter- und Setter-Methoden (wie in Ruby)
@@ -63,7 +64,7 @@ static void(args) {
 }
 ```
   
-- Konstruktoren
+### Konstruktoren
 
 Groovy fügt automatisch einen Standardkonstruktor hinzu. Man kann auch
 benutzerdefinierte Konstruktoren definieren.
@@ -79,16 +80,18 @@ class Person {
 }
 ```
 
-- Standardkonstruktor mit Map
+### Standardkonstruktor mit Map
 
 Groovy bietet eine spezielle Initialisierungsform mit einer Map an
   ```
   Person person = new Person(name: 'John', age: 30)
   ```
+  
+  
 
-## Methoden
+# Methoden
 
-- Definition einer Methode
+### Definition einer Methode
 
 Methoden werden ähnlich wie in Java definiert, können aber optional einen Rückgabetyp
 haben
@@ -121,7 +124,7 @@ sum(5,2)
 // 7
 ```
 
-- Instanzmethoden
+### Instanzmethoden
 
 Methoden können Instanzmethoden sein und auf Instanzvariablen zugreifen.
 ```
@@ -138,7 +141,7 @@ def myMethod() {
 }
 ```
 
-- Statische Methoden
+### Statische Methoden
 ```
 class MathUtils {
     // Definition einer statischen Methode
@@ -154,7 +157,7 @@ class MathUtils {
 }
 ```
 
-- Dynamische Methoden
+### Dynamische Methoden
 
 Groovy erlaubt es, Methoden zur Laufzeit hinzuzufügen. 
 In diesem Beispiel wird die Methode sayHello zur Klasse DynamicExample hinzugefügt, nachdem
@@ -171,11 +174,10 @@ def example = new DynamicExample()
 example.sayHello()
 ```
 
-- Expando
+### 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
 
-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
 ```
@@ -192,9 +194,9 @@ expando.sayHello = { -> println "Hello from $name" }
 expando.sayHello()  // Ausgabe: Hello from Groovy
 ```
 
-- Default-Parameterwerte
+### Default-Parameter
 
-Methodenparameter können Standdardwerte haben(wie in Ruby)
+Methodenparameter können Standdardwerte haben(wie in Ruby). Diese werden eingesetzt, falls beim Aufruf keine Parameter gesetzt werden.
 
 Beispiel 1
 ```
@@ -217,29 +219,43 @@ sum()
 ```
 
 
-- Closures
+### 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 abgegeben, 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
+    def count = 0  //lokale var
     return { ->
         count += 1
         return count
     }
 }
 
-def counter = createCounter()
+//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
   ```
@@ -256,7 +272,27 @@ 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 }
@@ -269,7 +305,16 @@ println myList.every { item -> item > 3 }  // false
 println myList.collect { item -> item * 2 }  // [2, 4, 6, 8, 10]
   ```
 
-- Methodenverkettung
+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
 
 Durch das Rückgeben von this kann man Methodenaufrufe verketten.
 
@@ -295,7 +340,8 @@ def person = new FluentPerson().setName("John").setAge(30)
   ```
 
 
-- Mixin(Misching)
+
+### Mixin(Misching)
 
 Man kann Funktionalität zu Klassen hinzufügen, ohne Vererbung zu verwenden, indem man
 Mixins verwendet.