Im Gegensatz zu Java werden Methoden in Scala ein wenig anders erstellt. Ich fand das zunächst etwas kompliziert, deswegen widme ich dem Thema Methoden in Scala einen eigenen Beitrag.
Methoden ohne Parameter
Methoden die keine Parameter besitzen sind wohl am einfachsten zu schreiben und benötigen die wenigsten Zeilen. Deswegen möchte ich damit beginnen.
Methoden werden definiert mit dem Schlüsselwort def gefolgt von dem Namen. Da es keine Parameter geben soll in diesem ersten Beispiel brauchen wir keine Parameterliste bzw. Eine leere Parameterliste und zum Schluss den eigentlichen Methodenrumpf. Erstellt wird die Methode hello so:
|
1 |
def hello = "Hello World!" |
Und aufgerufen wird sie mittels hello . Da es keine Parameterliste gibt ist der Aufruf von hello() nicht erlaubt. Die Methode gibt einfach den String Hello World! zurück.
Gehen wir die Methodendeklaration noch einmal im Detail durch:
Wenn man aus der Java oder C/C++ Welt kommt gibt es einige Sachen die anders sind als gewohnt. Das es ein eigenes Schlüsselwort zum erzeugen von Methoden gibt ( def ) kann man noch verstehen. Allerdings ist es etwas schwierig zu verstehen das es keine Parameterliste gibt. Die Sache ist die, wenn man keine Parameter hat, dann kann man die Liste einfach weglassen. Man könnte genauso gut schreiben def hello() = "Hello World!", was das gleiche Ergebnis liefert. Hier muss man jetzt aber hello() zum Aufrufen verwenden.
Das Gleichheitszeichen ( =) ist ebenso ungewohnt, trennt aber ganz Schlicht den Methodenkopf vom Methodenrumpf. Wenn man nur eine Zeile im Rumpf stehen hat, so wie wir hier, kann man diese einfach hinschreiben. Ansonsten muss man einen Block verwenden. Mit Block würde unsere Methode so aussehen:
|
1 2 3 |
def hello = { "Hello World!" } |
Weiterhin ungewohnt ist das es kein return Statement gibt. Dieses kann weggelassen werden. Die letzte ausgeführte Anweisung in einem Block ist der Rückgabewert. Hier also Hello World!
Rückgabetyp
Bis jetzt haben wir uns immer darauf verlassen, dass Scala selber herausfindet von welchem Typ unser Rückgabewert ist. Das nennt man Typinferenz und ist sehr praktisch. Gelegentlich möchte man jedoch selber etwas offensichtlicher zeigen welchen Typ wir zurückgeben.
|
1 |
def hello : String = "Hello World!" |
Der Rückgabetyp wir zwischen Parameterliste (in diesem Beispiel gibt es keine!) und das Gleichheitszeichen eingefügt. Für den Compiler macht das keinen Unterschied:
Die Struktur mit explizitem Rückgabetyp sieht immer so aus:
Methoden mit einem oder mehr Parameter
Angenommen wir möchten unsere Hello Methode so erweitern, dass ein String übergeben (etwa Klaus) wird und die Rückgabe dann Hello Klaus! Ist, müssen wir eine Parameterliste einführen. Die fertige Methode sieht so aus:
|
1 |
def hello(name: String) = "Hello " + name + "!" |
Die Parameterliste, welche eben noch optional war, ist jetzt verpflichtend. Die Variable name ist vom Typ String . Im Methodenrumpf wird der String zusammengebaut und zurückgegeben. Aufgerufen wird die Methode mittels hello(Klaus) . Was dann zu dem gewünschten Ergebnis führt.
Nun möchten wir oftmals nicht nur einen Parameter übergeben sondern mehrere. Dafür schreiben wir einfach mehrere Parameter mit Komma getrennt hintereinander in die Parameterliste. Wenn wir also etwa unseren ersten Teil des Strings (Hello) veränderlich manchen möchten, dann könnte die Methode etwa so aussehen:
|
1 |
def hello(prefix: String, name: String) = prefix + " " + name + "!" |
Nach dem diesem Prinzip können wir beliebig viele Parameter in Methoden verwenden.
Defaultparameter
Wenn es eine Methode gibt, welche eigentlich immer mit den gleichen Parametern aufgerufen wird, kann man Defaultparamter verwenden. In unserer hello-Methode könnten wir etwa Hallo als Defaultwert für prefix nehmen und World für name.
|
1 2 3 |
def hello(prefix: String = "Hello", name = "World") = { prefix + " " + name + "!" } |
Die Methode kann jetzt aufgerufen werden als
|
1 2 3 4 5 6 7 8 |
hello() > Hello World! hello("Guten Tag") > Guten Tag World! hello("Guten Tag", "Klaus") > Guten Tag Klaus! |
Wenn man jetzt allerdings nur den Parameter name setzen möchte gibt es eine nette Kleinigkeit die sich Named Parameter nennt. Letztlich ist es ohne belang in welcher Reihenfolge die Parameter aufgeschrieben werden, solange der Compiler weiß welchen Wert er welcher Variablen zuordnen soll.
|
1 2 |
hello(name="Klaus") > Hello Klaus! |
Mehrere Parameterlisten
In Scala gibt es die Möglichkeit nicht nur eine Parameterliste anzugeben, sonder beliebig viele. Die oben vorgestellte Methode hello(String, String) könnte man auch als
|
1 |
def hello(prefix:String)(name:String) = prefix + " " + name + "!" |
deklarieren. Der Methodenrumpf bleibt genau so bestehen, das interessante ist jedoch, dass es jetzt zwei runde Klammern gibt. Eine für prefix und eine für name. Aufgerufen wird diese Methode jetzt mittels hello("Hello")("World") . Das Ergebnis ist das gewohnte Hello World!
Dies Verwendung wird besonders nützlich, wenn man Scalas Currying verwenden möchte. Das erkläre ich jedoch in einem eigenen Artikel, da man dazu nicht nur Methoden sondern auch Funktionen kennen muss.
Fazit
Methoden in Scala bieten einige interessante Möglichkeiten, welche man aus der Java oder C/C++ Welt her nicht kennt. Zum einen besteht die Möglichkeit beliebig viele Parameterlisten zu erstellen (oder auch keine) und zum anderen muss man kein return Statement verwenden. Das Gleichheitszeichen zwischen Methoden Kopf und Rumpf ist ungewohnt, man kann sich jedoch schnell daran gewöhnen.
