Upload files to "/"

Datentypen.md

@@ -0,0 +1,143 @@
+# Datentypen
+
+Groovy unterstützt alle eingebauten Datentypen von Java und
+hat zusätzlich eigene Datentypen & erweitere Funktionen, die die Sprache
+dynamischer und benutzerfreundlicher machen
+
+### Primitive Datentypen
+```
+• Logisch - boolean
+    zwei mögl. Werte: true und false
+• Ganzzahl – byte, short, int, long
+    8, 16, 32, 64 Bit vorzeichenbehaftete Ganzzahlen
+• Fliesskommazahlen – float, double 32 bzw. 64 Bit
+• Zeichen – char
+    16-Bit Unicode
+```
+
+Es entählt noch die eingebauten Datentypen BigInteger & BigDecimal 
+sie müssen nicht zusätzlich importiert werden - zählen aber zu den koplexen Datentypen
+
+Beispiel
+```
+- für 'long' nutzt man L/l am Ende der Zahl - 100L
+- für 'float' nutzt man F/f - 3.14f
+- für 'BigInteger' nutzt man G/g - 34567890G
+- für 'BigDecimal' nutzt man G/g - 3.14159g
+```
+
+wenn man das Schlüsselwort "def" verwendet, muss der Variablentyp
+nicht angegeben werden. Das Programm erkennt autom. welchen Datentyp
+die Variable haben soll 
+Wenn man z.B. eine grosse Zahl hat, wird der Typ automatisch an die grössere Zahl angepasst
+
+Beispiel
+```
+def a = 100
+boolean isInteger = a Instance of Integer
+println(isInteger) //-> true
+```
+
+
+### Komplexe Datentypen
+
+# Strings
+Man kann einen String auf verschiedene Arten definieren. 
+Sie reichen von einfachen einzeiligen Strings ... 
+Beispiel
+```
+def einfach = 'einfache Anführungszeichen'
+def doppelt = "doppelte Anführungszeichen"
+def slashy = /ein "Slashy String" ohne 'Escape'/
+def dollar = $/weitere Möglichkeit und Einfügen von '/'/$ 
+
+println(einfach) // einfache Anführungszeichen
+println(doppelt) // doppelte Anführungszeichen
+println(slashy) // ein "Slashy-String" ohne 'Escape'
+println(dollar) // weitere Möglichkeit und Einfügen von '/'
+```
+
+...bis hin zu komplexen mehrzeiligen Textblöcken
+Beispiel
+```
+def dreifach = '''
+Ich bin
+ein String der über
+mehrere Zeilen geht/n'''
+
+def tripple = """
+erste Zeile
+zweite Zeile
+dritte Zeile"""
+
+println(dreifach)
+//Ich bin
+//ein String der über
+//mehrere Zeilen geht
+
+println(tripple)
+//erste Zeile
+//zweite Zeile
+//dritte Zeile
+```
+
+### Statische vs. dynamische Typisierung
+Java = statisch typisiert d.h. der Typ der Variablen
+wird zur Kompilierungszeit festgelegt und kann sich nicht ändern
+Beispiel 
+```
+String s = "Hallo Welt";
+System.out.println(s); // Hallo Welt
+
+s = 123;
+System.out.println(s); // -> Compiler-Fehler
+```
+
+Groovy = dynamisch typisiert d.h. der Typ der Variablen
+wird zur Laufzeit bestimmt. Daher ist es auch möglich
+einer Variablen die zuvor einen String-Wert hatte, einen Integer-Wert zuzuweisen
+Beispiel
+```
+def s = "Hallo Welt"
+println s.getClass() // -> class java.lang.String
+
+s = 123
+println s.getClass() // -> class java.lang.Integer
+```
+
+### GString
+Man kann jede Art von Ausdruck in String-Literale einfügen, ausser
+einfach (') und dreifach einfach angeführte Strings (''').
+Dabei wird ein Platzhalter im String durch seinen tatsächlichen Wert ersetzt, wenn 
+der String ausgewertet wird. 
+Platzhalter werden durch `${ausdruck}` gekennzeichnet
+Beispiel
+```
+def person = [name: 'Thomas Smits', lehrt: 'PR3']
+def hochschule = "Hochschule Mannheim"
+def ausdruck = "Hallo, mein Name ist ${person.name}. Ich unterrichte ${person.lehrt}. An der ${hochschule}."
+
+println(ausdruck) // -> Hallo, mein Name ist Thomas Smits. Ich unterrichte PR3. An der Hochschule Mannheim
+```
+Man nennt dies einen `GString`
+
+### String Konkatenation
+Jeder String kann mit '+' konkateniert werden
+Beispiel
+```
+def eins = "Ein String"
+def zwei = ' wird konkateniert'
+
+println(eins + zwei) // -> Ein String wird konkateniert 
+```
+
+### String Index
+Man kann auf Zeichen eines Strings mit positiven und negativen Indizes zugreifen
+Zählungen beginnen bei null und negative Indizes beginnen den String am Ende
+Beispiel
+```
+def greeter = "Hallo Welt"
+
+println(greeter[1]) // -> 'a'
+println(greeter[-4]) // -> 'W'
+```