groovy-lecture/skript/datentypen.md

# 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
```Groovy
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
```Groovy
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
```Groovy
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 
```Groovy
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:
```Groovy
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:
```Groovy
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
```Groovy
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
```Groovy
def greeter = "Hallo Welt"

println(greeter[1]) // -> 'a'
println(greeter[-4]) // -> 'W'
```