Merge branch 'main' of https://gitty.informatik.hs-mannheim.de/3003916/groovy-lecture

Bedingungen.md

@@ -3,55 +3,69 @@ Groovy entscheidet nach folgenden Regeln, ob ein Ausdruck true oder false ist:
 
 ##### Boolean
 True wenn entsprechender boolean Wert true ist
-``assert true
-``assert !false
+``` Groovy 
+assert true
+assert !false
+```
 
 ##### Collections und Arrays
 Non-Empty Collections und arrays sind true
-``assert [1,2,3]
-``assert ![]
+``` Groovy
+assert [1,2,3]
+assert ![]
+```
 
 ##### Matchers
 True wenn mind. ein "match" 
-``assert = 'a' =~ /a/
-``assert = !('a' =~ /b/)
+``` Groovy
+assert 'a' =~ /a/
+assert !('a' =~ /b/)
+```
 
 ##### Iterators und Enumerations
 Iteratoren und Enumerationen mit weiteren Elementen sind true
 ```Groovy
 assert [0].iterator()
-assert ![].iterator()
+assert ![].iterator.hasNext()
 Vector v = [0] as Vector
 Enumeration enumeration = v.elements()
-assert enumeration
+assert Enumeration
 enumeration.nextElement()
-assert !enumeration
+assert !enumeration.hasMoreElements()
 ```
 
 ##### Maps
 Non-Empty Maps sind true
-``assert ['one' : 1]
-``assert ![:]
+``` Groovy
+assert ['one' : 1]
+assert ![:]
+```
 
 ##### Strings
 Non-Empty Strings, GStrings, CharSequences sind true
-``assert 'a'
-``assert !''
-``def nonEmpty = a
-``assert "$nonEmpty"
-``def empty = ''
-``assert !"$empty"
+``` Groovy
+assert 'a'
+assert !''
+def nonEmpty = a
+assert "$nonEmpty"
+def empty = ''
+assert !"$empty"
+```
 
 ##### Numbers
 Non-zero Nummern sind true
-``assert 1
-``assert 3.5
-``assert !0
+``` Groovy
+assert 1
+assert 3.5
+assert !0
+```
 
 ##### Object References
 Non-null Objekt-Referenzen sind true
-``assert new Object()
-``assert !null
+``` Groovy 
+assert new Object()
+assert !null
+```
 
 ##### Truth verändern mit asBoolean()-Methode
 Man kann das Verhalten von Groovy auf boolean verändern, indem man eine asBoolean()-Methode implementiert
@@ -66,7 +80,7 @@ class Color{
 	}
 }
 
-...
+// ...
 
 assert new Color(name: 'green')
 assert !new Color(name: 'red')
@@ -112,13 +126,13 @@ result = string ? 'Found' : 'Not Found'
 ```
 
 ### Elvis-Operator
-Der "Elvis-Operator" ist eine Kurzform des ternären Operators. Dieser wird verwendet, um einen Standardwert anzugeben, wenn eine Variable "null" oder leer ist. 
+Der "Elvis-Operator" ist eine Kurzform des ternären Operators. Dieser wird verwendet, um einen Standardwert anzugeben, wenn eine Variable "null" oder falsly ist. 
 
 ```Groovy
 def result = ausdruck1 ?: ausdruck2
 ```
 - ausdruck1: Dies ist der Ausdruck der ausgewertet wird, wenn dieser einen "truthy" Wert hat.
-- ausdruck2: Dies ist der Asudruck, wenn ausdruck1 "null" oder "falsly" ist
+- ausdruck2: Dies ist der Ausdruck, wenn ausdruck1 "null" oder "falsly" ist
 
 
 ### If-Else Bedingungen
@@ -161,9 +175,9 @@ switch (x) {
 
 Switch Unterstützt folgende Arten des Vergleichs:
 - Case-Values stimmen überein, wenn Switch-Value ein Instanz der selben Klasse ist
-- "Regulärer Ausdruck Case" stimmt überein, wenn `toString()` Repräsentation vom Switch-Value dem Regex gleicht
-- Collection Case-Values matchen mit dem Switch-Value, wenn Switch-Value in der Collection vorkommt
-- Closure Case-Values matcht, wenn der Call auf dem Clojure ein Return basierend auf Groovy-Truth zurück gibt
+- "Regulärer Ausdruck Case"-Value stimmt überein, wenn `toString()` Repräsentation vom Switch-Value dem Regex gleicht
+- "Collection Case"-Values matchen mit dem Switch-Value, wenn Switch-Value in der Collection vorkommt
+- Closure Case-Values match, wenn der Call auf dem Clojure ein Return basierend auf Groovy-Truth zurück gibt
 
 Groovy unterstützt auch folgende Schreibweise: 
 ```Groovy

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.