Übersicht:

	Sicheres Dereferenzieren
	Indizierter Zugriff auf Arrays und Listen
	Optionale Parameter, benannte Parameter & Parameterlisten
	Einfache Typen
	Getter und Setter
	Strings und Reguläre Ausdrücke
	Überladen von Operatoren
	Der Typ Range

Sicheres Dereferenzieren

class A {
    String s = "foo";
}
A a = null;
assert null == a?.s; //!!
a = new A();
assert "foo" == a?.s;

Indizierter Zugriff auf Arrays und Listen

Optionale Parameter, benannte Parameter & Parameterlisten

In vielen Programmiersprachen werden Parameter von Funktionen anhand der Reihenfolge der formalen und aktuellen Parameter zugeordnet. Der erste aktuelle Parameter entspricht dabei dem ersten formalen Parameter usw. In Groovy ist es möglich, wie auch in Python und VHDL, Parameter anhand ihres Namens zu identifizieren.

String concat(Map args)
{
    return args.get("a", "anfang") + args.get("limiter", "") + args.get("b", "ende");
}
assert "schallrauch" == concat(a:"schall", b:"rauch", limiter:"");
assert "anfang bis ende" == concat(limiter:" bis ");

Ab der Version 1.5 ist es auch in Java möglich, beliebige viele Parameter zu übergeben, indem man die ... Syntax bei der Funktionsdeklaration nutzt, was man auch unter dem Namen variable Parameterliste kennt. In Groovy nutzt man stattdessen ein Object[] als letzten Parameter. Auch in Java ist der letzte Parameter implizit bei der ... Notation ein Array.

int sum(Object[] l)
{
    int res = 0;
    for(o in l)	{
	res += o;
    }
    return res;
}
assert sum(2, 3, 37) == 42;
assert sum() == 0;

Im Vergleich mit Java sind die optionalen Parameter tatsächlich neu. Im Gegensatz zu den variablen Parameterlisten bleibt die maximale Anzahl der aktuellen Parameter begrenzt.

String concat(String msg, String extension = "")
{
    return msg + extension;
}
assert "schall" == concat("schall");
assert "ab" == concat("a", "b");

Einfache Typen

Gegenüber Java gibt es in Groovy einige Besonderheiten bei der Typisierung. Es gibt keine einfachen Typen mehr, diese werden durch die entsprechende Wrapper-Klasse ersetzt.

int i = 42;
println i.class
j = 42.0
println j.class
double k = 42
println k.class

          class java.lang.Integer
          class java.math.BigDecimal
          class java.lang.Double
        

1/2 == 0.5

(1/3)*3 != 1

Getter und Setter

In Java wird automatisch ein öffentlicher Konstruktor generiert, wenn der Programmierer keinen explizit angibt. In Groovy werden zusätzlich zu jedem Objekt-Attribut

T xxx;

public void setXxx(T value) { this.xxx = value; }

public T getXxx() { return this.xxx; }

Vorsicht: Dieses Feature wurde noch nicht implementiert.

Strings und Reguläre Ausdrücke

In Java ist es recht umständlich, mehrzeilige Strings einzugeben. Daher hat man in Groovy die Möglichkeit HERE-Dokumente einzugeben, wie es in der bash üblich ist:

String msg = """
ein text, der ganz
viele
Zeilen
hat"""

println msg

In den meisten Skriptsprachen, zum Beispiel Tcl, gibt es Möglichkeiten in einem String-"Literal" Ausdrücke anzugeben, welche zur Laufzeit ausgewertet werden. Dies ist in Groovy mit GStrings möglich. Es können darin Variablenbezeichner durch ihren aktuellen Wert ersetzt werden:

int alter = 42
println "ich bin $alter Jahre alt"
println "ich bin ${alter} Jahre alt"

println """heute ist:
${new Date()}"""

println """gestern war:
${new Date() - 1}"""

Um eine Zeichenkette mit vielen Escape-Sequenzen darzustellen, kann diese in Schrägstriche (/) geklammert werden. Bei dieser "slashy" Syntax werden alle umgekehrten Schrägstriche so übernommen, wie sie eingegeben werden. Dies ist insbesondere bei Regulären Ausdrücken hilfreich, da in deren Syntax viele Backslashes vorkommen.

Insgesamt gibt es fünf Darstellungsmöglichkeiten für Strings und GStrings: 'foo', "foo", '''foo''', """foo""", /foo/ repräsentieren alle die gleiche Zeichenkette. Die unterschiedlichen Begrenzer haben folgenden Eigenschaften:

• Drei Mal geklammerte Strings können mehrzeilig eingegeben werden.
• Einfache Anführungszeichen, egal ob ein Mal oder drei Mal geklammerte, verhindern die Auswertung von GStrings.

Groovy bietet eine Unterstützung für Reguläre Ausdrücke auf Syntax-Ebene, es werden dazu drei Operatoren bereitgestellt:

• s =~ re Ergibt genau dann true, wenn re in s enthalten ist.
• s ==~ re Ergibt genau dann true, wenn re dem kompletten String s entspricht.
• ~String erzeugt einen Regulären Ausdruck aus dem String vom Typ java.util.regex.Pattern. Dadurch kann das häufige Neuerzeugen eines Pattern-Objektes verhindert werden.

Überladen von Operatoren

In Java sind für Referenztypen lediglich die Vergleichsoperatoren erlaubt, sowie für die Stringverknüpfung der + Operator. In Groovy wird viel mehr mit Operatoren als mit Funktionsnamen gearbeitet, was die Lesbarkeit erhöhen kann. Die Wrapperklassen der einfachen Datentypen überschreiben beispielsweise die arithmetischen Operatoren. Das Überladen von Operatoren kann aber auch vom Anwendungsprogrammierer vorgenommen werden, da alle Operatoren auf einen Funktionsnamen abgebildet werden. Die folgende Tabelle, gibt einige Beispiele dazu an.

Der Index-Operator [] kann dazu genutzt werden, auf Attribute lesend oder schreibend zuzugreifen. Damit ist es möglich den Namen des Attributs, welches man bearbeiten möchte, zur Laufzeit zu berechnen:

class Foo
{
    String schall = "laut"
}
String name = "schall"
Foo foo = new Foo();
foo[name] = "42"
println foo.schall
println foo[name]

Mit Switch-Anweisungen lassen sich beliebige Objekte vergleichen, nicht nur ints wie in Java. Im folgenden Beispielcode wird überprüft, ob ein Objekt eine Zahl oder einen String enthält:

Object o = 3.3;
switch(o) {
case String:
    println "ein string";
    break;
case Integer:
    println "eine ganze Zahl";
    break;
default:
    println "was anderes";
    break;
}

Etwas sinnvoller lässt sich mit Hilfe von Switch-Anweisungen testen, welchem Regulären Ausdruck ein String entspricht:

//String userInput = "23:59";
String userInput = "42a";
switch(userInput) {
case ~/[0-9]+/:
    println "eine Zahl";
    break;
case ~/[0-2][0-9]:[0-5][0-9]/:
    println "eine Uhrzeit";
    break;
default:
    println "was anderes";
    break;
}

switch Anweisungen entsprechen eher verschachtelten else-if Strukturen, als Java-switches. Daher muss bei der Nutzung von komplexen Datentypen in switch Anweisungen immer darauf geachtet werde, die korrekte Reihenfolge einzuhalten.

Eine weitere Möglichkeit bieten switch Anweisungen in Kombination mit Closures. Beliebige boolesche Ausdrücke lassen sich somit kompakt in einer Anweisung formulieren, ohne auf die else-if Schachtelungen zurückgreifen zu müssen. Die Variable it wird immer mit dem zu überprüfenden Wert belegt.

int userInput = 123;
switch(userInput) {
case {it % 2 == 0}:
    println "gerade";
    break;
case {it % 10 == 3}:
    println "endet mit 3";
    break;
default:
    println "was anderes";
    break;
}

Der Typ Range

for( i in 24..29) {
    println i;
}

Der Operator .. erzeugt einen beidseitig inklusiven Bereich, der Operator ..< einen rechtsseitig exklusiven Bereich.

Ranges können sehr Speicherplatzt-sparend implementiert werden. Ein Range besteht aus einer linken und einer rechten Grenze, sowie einer Funktion zum inkrementieren und einer zum dekrementieren. Die linke Grenze muß nicht zwangsläufig die kleinere sein, in dem Fall wird einfach die Reihenfolge umgekehrt.

• die ++ und -- Operatoren überschreiben
• java.lang.Comparable implementieren

for( i in ("fol"..<"fop")) {
    println i;
}

        fol
        fom
        fon
        foo