groovy-lecture/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
```
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'
```