Scala – Objektfunktionale Programmierung

oliver BRAUN
SCALA
OBJEKTFUNKTIONALE PROGRAMMIERUNG
Inhaltsverzeichnis
Vorwort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
XI
1
Einführung . . . . . . . . . . . . . . . . . . . . . . .
1.1 Was Führungskräfte über Scala wissen sollten
1.2 Java-Scala-Integration . . . . . . . . . . . . . .
1.3 Über dieses Buch . . . . . . . . . . . . . . . . .
1.4 Typographische und sonstige Konventionen .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
3
4
5
6
2
Einrichten der Arbeitsumgebung . . . . . .
2.1 Die Scala-Shell und die Kommandozeile
2.1.1 Der Scala-Interpreter . . . . . . .
2.1.2 Die Scala-(De-)Compiler . . . . .
2.1.3 Der Dokumentationsgenerator .
2.2 Buildtools . . . . . . . . . . . . . . . . .
2.2.1 Das Maven-Scala-Plugin . . . . .
2.2.2 Simple Build Tool . . . . . . . . .
2.3 IDE-Support . . . . . . . . . . . . . . . .
2.3.1 Eclipse . . . . . . . . . . . . . . .
2.3.2 NetBeans . . . . . . . . . . . . . .
2.3.3 IntelliJ IDEA . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
9
9
11
13
16
17
17
19
22
22
23
24
3
Grundlagen . . . . . . . . . . . . .
3.1 Ein kleines bisschen Syntax .
3.2 Imperative Programmierung
3.3 Ein ausführbares Programm .
3.4 Annotations . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
27
27
39
42
44
4
Reine Objektorientierung . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1 Klassen und Objekte . . . . . . . . . . . . . . . . . . . . . . . . . . .
47
47
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
VIII
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
47
60
62
65
67
73
78
78
79
80
82
83
88
95
Funktionales Programmieren . . . . . . . . . . . . . . . . .
5.1 Lazy Evaluation . . . . . . . . . . . . . . . . . . . . . .
5.2 Funktionen und Rekursionen . . . . . . . . . . . . . .
5.3 Higher-Order-Functions . . . . . . . . . . . . . . . . .
5.4 Case-Klassen und Pattern Matching . . . . . . . . . .
5.4.1 Case-Klassen . . . . . . . . . . . . . . . . . . .
5.4.2 Versiegelte Klassen . . . . . . . . . . . . . . . .
5.4.3 Partielle Funktionen . . . . . . . . . . . . . . .
5.4.4 Variablennamen für (Teil-)Pattern . . . . . . .
5.4.5 Exception Handling . . . . . . . . . . . . . . .
5.4.6 Extraktoren . . . . . . . . . . . . . . . . . . . .
5.4.7 Pattern Matching mit regulären Ausdrücken .
5.5 Currysierung und eigene Kontrollstrukturen . . . . .
5.6 For-Expressions . . . . . . . . . . . . . . . . . . . . . .
5.7 Typsystem . . . . . . . . . . . . . . . . . . . . . . . . .
5.7.1 Standardtypen . . . . . . . . . . . . . . . . . .
5.7.2 Parametrischer Polymorphismus und Varianz
5.7.3 Upper und Lower Bounds . . . . . . . . . . . .
5.7.4 Views und View Bounds . . . . . . . . . . . . .
5.7.5 Context Bounds . . . . . . . . . . . . . . . . . .
5.7.6 Arrays und @specialized . . . . . . . . . . . .
5.7.7 Generalized Type Constraints . . . . . . . . . .
5.7.8 Self-Type-Annotation . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
101
102
104
108
114
119
122
124
126
126
128
130
132
141
147
147
148
151
154
155
155
158
160
4.2
4.3
4.4
5
Inhaltsverzeichnis
4.1.1 Felder und Methoden . . . . . . . . . . .
4.1.2 Was Klassen sonst noch enthalten können
4.1.3 Konstruktoren . . . . . . . . . . . . . . . .
4.1.4 Enumerations . . . . . . . . . . . . . . . .
4.1.5 Vererbung und Subtyping . . . . . . . . .
4.1.6 Abstrakte Klassen . . . . . . . . . . . . .
Codeorganisation . . . . . . . . . . . . . . . . . .
4.2.1 Packages . . . . . . . . . . . . . . . . . . .
4.2.2 Package Objects . . . . . . . . . . . . . . .
4.2.3 Importe . . . . . . . . . . . . . . . . . . .
Traits . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.1 Rich Interfaces . . . . . . . . . . . . . . .
4.3.2 Stapelbare Modifikationen . . . . . . . . .
Implicits und Rich-Wrapper . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Inhaltsverzeichnis
5.7.9
IX
Strukturelle und existenzielle Typen . . . . . . . . . . . . . . 162
6
Die Scala-Standardbibliothek . . . . .
6.1 Überblick und das Predef-Objekt
6.2 Das Collection-Framework . . . . .
6.3 Scala und XML . . . . . . . . . . .
6.4 Parser kombinieren . . . . . . . . .
6.5 Ein kleines bisschen GUI . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
165
165
170
176
180
187
7
Actors – Concurrency und Multicore-Programmierung .
7.1 Ein Thread ist ein Actor . . . . . . . . . . . . . . . .
7.2 Empfangen und Reagieren . . . . . . . . . . . . . . .
7.3 Dämonen und Reaktoren . . . . . . . . . . . . . . . .
7.4 Scheduler . . . . . . . . . . . . . . . . . . . . . . . . .
7.5 Remote Actors . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
193
194
196
207
209
211
8
Softwarequalität – Dokumentieren und Testen . . . . . .
8.1 Scaladoc . . . . . . . . . . . . . . . . . . . . . . . . . .
8.2 ScalaCheck . . . . . . . . . . . . . . . . . . . . . . . . .
8.2.1 Grundlagen . . . . . . . . . . . . . . . . . . . .
8.2.2 Generatoren . . . . . . . . . . . . . . . . . . . .
8.2.3 Automatisiertes Testen mit Sbt . . . . . . . . .
8.3 ScalaTest . . . . . . . . . . . . . . . . . . . . . . . . . .
8.3.1 ScalaTest und JUnit . . . . . . . . . . . . . . . .
8.3.2 ScalaTest und TestNG . . . . . . . . . . . . . .
8.3.3 ScalaTest und BDD . . . . . . . . . . . . . . . .
8.3.4 Funktionale, Integrations- und Akzeptanztests
8.3.5 Die FunSuite . . . . . . . . . . . . . . . . . . .
8.4 Specs . . . . . . . . . . . . . . . . . . . . . . . . . . . .
8.4.1 Eine Specs-Spezifikation . . . . . . . . . . . . .
8.4.2 Matchers . . . . . . . . . . . . . . . . . . . . . .
8.4.3 Mocks mit Mockito . . . . . . . . . . . . . . . .
8.4.4 Literate Specifications . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
215
216
221
221
224
229
232
233
235
236
238
240
241
242
244
248
249
9
Webprogrammierung mit Lift . . . . . .
9.1 Quickstart mit Lift . . . . . . . . . .
9.2 Bootstrapping . . . . . . . . . . . . .
9.3 Rendering – Templates und Snippets
9.4 Benutzerverwaltung und SiteMap .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
253
254
257
262
264
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
X
Inhaltsverzeichnis
9.5
9.6
Persistenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Implementierung der Snippets . . . . . . . . . . . . . . . . . . . . . 269
10 Leichtgewichtige Webprogrammierung mit Scalatra . . . . . . . . . . . 279
10.1 Quickstart mit Scalatra . . . . . . . . . . . . . . . . . . . . . . . . . . 279
10.2 Der Final-Grade-Calculator . . . . . . . . . . . . . . . . . . . . . . . 281
11 Akka – Actors und Software Transactional Memory
11.1 Quickstart mit Akka . . . . . . . . . . . . . . . .
11.2 Der MovieStore . . . . . . . . . . . . . . . . . . .
11.3 User- und Session-Management . . . . . . . . . .
11.4 Software Transactional Memory . . . . . . . . . .
11.5 Client und Service . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
287
288
289
293
297
300
Schlusswort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
Literaturverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Stichwortverzeichnis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
Kapitel 1
Einführung
Schon wieder eine neue Programmiersprache, obwohl: Scala ist gar nicht mehr so
neu. Die Entwicklung begann 2001 an der École polytechnique fédérale de Lausanne (EPFL) in der Schweiz von einem Team um Professor Martin Odersky. Das
erste Release wurde bereits 2003 veröffentlicht. 2006 folgte die Version 2.0 und
2010, gerade während dieses Buch geschrieben wird, wird die Version 2.8 freigegeben, die laut Odersky eigentlich 3.01 heißen müsste.
Professor Odersky ist in der Java-Welt kein Unbekannter. 1995 begann er mit Philip Wadler2 mit der Entwicklung der funktionalen Programmiersprache Pizza3 ,
die sich in Bytecode für die Java Virtual Machine (JVM) übersetzen lässt. Diese
Arbeit führte über GJ4 schließlich zum neuen javac-Compiler und den mit Java
5 eingeführten Java Generics5 .
Als Odersky 1999 an die EPFL kam, verschob er seinen Fokus etwas. Er hatte
immer noch das Ziel, die objektorientierte und funktionale Programmierung zu
verbinden, wollte sich aber nicht mehr mit den Restriktionen von Java belasten.
Nach der Entwicklung der Programmiersprache Funnel6 nahm er als weitere Ziele
die praktische Verwendbarkeit und die Interoperabilität mit Standardplattformen
hinzu und entwarf Scala7 .
Scala ist eine Hybrid-Sprache, die auf einzigartige Weise Features von objektorientierten und funktionalen Programmiersprachen verbindet. Designziel von Scala
1
Eigentlich sollte nur das Collection-Framework (siehe Abschnitt 6.2) einem Redesign unterworfen
werden. Die Arbeiten daran dauerten aber etwa 18 Monate, sodass parallel dazu eine Vielzahl anderer Features entstanden, die in die bereits angekündigte Version 2.8 aufgenommen wurden. Von der
bereits kommunizierten Versionsnummer wollte das Scala-Team nicht mehr abweichen.
2 http://homepages.inf.ed.ac.uk/wadler/
3 siehe [OW97] und http://pizzacompiler.sourceforge.net/
4 siehe [BOSW98] und http://lamp.epfl.ch/pizza/gj/
5 siehe [NW06]
6 siehe [Ode00] und http://lampwww.epfl.ch/funnel/
7 siehe [Ode10b] und http://www.scala-lang.org/
2
1 Einführung
ist eine knappe, elegante und typsichere Programmierung. Scala wird nicht nur in
Bytecode für die JVM kompiliert, es lässt sich auch jeglicher Java-Code direkt aus
Scala heraus nutzen und umgekehrt.
Scala ist eine rein objektorientierte Programmiersprache. Das heißt, in Scala ist jeder Wert ein Objekt. Scala nutzt ein Konzept von Klassen und Traits. Mit Traits
lassen sich Rich-Interfaces realisieren, denn Traits können bereits konkrete Implementierungen enthalten. Klassen werden durch Vererbung erweitert, Traits werden in eine Klasse oder in ein Objekt hineingemixt. Um nicht in typische Probleme
mit Mehrfachvererbung zu laufen, werden Traits linearisiert.
Ob Scala sich funktionale Programmiersprache nennen darf, wurde im Web kürzlich erst ausführlich diskutiert. Odersky bezeichnet Scala schließlich in [Ode10a]
als postfunktionale Sprache. Fest steht auf alle Fälle, dass Scala über eine Reihe
von Features verfügt, die entweder der funktionalen Programmierung zuzurechnen sind oder aus ihrem Umfeld entstammen.
In Scala ist jede Funktion ein Wert8 und kann gleichberechtigt mit anderen Werten behandelt werden. Das bedeutet beispielsweise, eine Funktion kann Argument oder Ergebnis einer anderen Funktion9 sein, Funktionen können in Listen
gespeichert werden, und Funktionen können ineinander verschachtelt werden.
Darüber hinaus unterstützt Scala auch Features wie Pattern Matching10 und Currysierung11 .
Im Gegensatz zu vielen modernen und angesagten Programmiersprachen ist Scala statisch typisiert. Das heißt, der Typ aller Ausdrücke wird zur Kompilierzeit
überprüft und nicht erst zur Laufzeit, wie es bei dynamisch typisierten Sprachen
der Fall ist. Nachdem eine überwiegende Anzahl von Programmierfehlern Typfehler sind, ist die statische Typisierung unserer Ansicht nach im allgemeinen vorzuziehen. Dem wesentlichen Nachteil, nämlich der Notwendigkeit, überall Typen
angeben zu müssen, wird in Scala mit einem Typinferenzmechanismus begegnet. Damit ist es an den meisten Stellen nicht notwendig Typen anzugeben. Beim
Übersetzen wird der Typ dann inferiert und überprüft, ob alles zusammenpasst.
Scala hat ein sehr ausgefeiltes Typsystem, das neben generischen Klassen und
polymorphen Methoden auch Varianz-Annotationen, Upper und Lower Bounds
und vieles mehr zur Verfügung stellt.
Ein weiteres Merkmal von Scala, was übrigens für Scalable Language steht, ist
die einfache Erweiterbarkeit. Damit ist Scala prädestiniert zur Erstellung von Domain Specific Languages (DSLs). Zu guter Letzt kann Scala auch noch mit Unterstützung für die .NET-Plattform aufwarten. Dabei handelt es sich allerdings noch
nicht um einen Stand, der als „production ready” zu bezeichnen ist.
8
und damit ein Objekt
Funktionen, die eine Funktion als Argument oder Ergebnis haben, heißen Higher Order Functions,
zu deutsch: Funktionen höherer Ordnung.
10 siehe Abschnitt 5.4
11 siehe Abschnitt 5.5
9
1.1 Was Führungskräfte über Scala wissen sollten
3
Scala auf der JVM ist seit Langem ausgewachsen und kann in allen Situationen,
auch unternehmenskritisch, eingesetzt werden. Die Weiterentwicklung von Scala
ist sehr aktiv, von Bugfix-Releases über neue Features wird uns in der nächsten
Zeit noch einiges erwarten. Für die kommenden Jahre steht der Fokus des ScalaTeams auf der noch besseren Unterstützung von Multicore-Architekturen.
1.1
Was Führungskräfte über Scala wissen sollten
Scala ist eine erwachsene, sehr durchdachte Programmiersprache. Mit Scala können Sie uneingeschränkt alles machen, was mit Java auch gemacht werden kann.
Nachdem Scala in Bytecode für die JVM kompiliert wird, also in Java-Bytecode,
können Sie den einmal erstellten Scala-Code natürlich auch aus Java heraus nutzen. Zusammenfassend heißt das: Scala kann gefahrlos ausprobiert werden. Selbst
wenn zu Java zurückgewechselt werden sollte, ist die Arbeit in Scala nicht umsonst. Und die gesamte Werkzeugpalette, die für die Java-Entwicklung genutzt
wird, wie z.B. Eclipse, NetBeans oder Maven, wird zur Entwicklung von ScalaCode einfach weiter benutzt.
Warum aber sollten Sie überhaupt zu Scala wechseln? Scala erhöht die Produktivität! Scala bietet eine Vielzahl von Features, mit denen Sie kürzeren und eleganteren Code schreiben können. Sicherlich ist die bloße Anzahl von Lines of Code
nicht sehr aussagekräftig, aber mit weniger Code gibt es mindestens statistisch
gesehen auch weniger Fehler. Scala ist strenger typisiert als Java. Auch dadurch
schlupfen weniger Fehler durch. Und ein wesentlicher Vorteil beim Start mit Scala ist, dass es sich fast wie Java anfühlt und zusätzliche Features nach und nach
eingeflochten werden können.
Warum denn Scala und nicht eine der unzähligen anderen Sprachen? Dazu möchten wir nur einige Zitate wiedergeben:
„If I were to pick a language to use today other than Java, it would be Scala.”
James Gosling, Schöpfer von Java
„Scala, it must be stated, is the current heir apparent to the Java throne. No other
language on the JVM seems as capable of being a “replacement for Java” as Scala, and the momentum behind Scala is now unquestionable. While Scala is not a
dynamic language, it has many of the characteristics of popular dynamic languages, through its rich and flexible type system, its sparse and clean syntax, and its
marriage of functional and object paradigms.”
Charles Nutter, Schöpfer von JRuby
„Though my tip though for the long term replacement of javac is Scala. I’m very
impressed with it! I can honestly say if someone had shown me the Programming
4
1 Einführung
in Scala book by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I’d
probably have never created Groovy.”
James Strachan, Schöpfer von Groovy
Wer nutzt Scala noch? Scala ist mittlerweile in einer Reihe von Firmen wie Sony,
Siemens und Xerox angekommen. Betrachten wir beispielhaft zwei Erfolgsgeschichten:
1. Électricité de France Trading (EDFT) ist eine Tochterfirma von Frankreichs
größter Energiefirma EDF, die sich mit dem Energiemarkt befasst. In den letzten Jahren hat EDFT einen substanziellen Teil der 300.000 Zeilen Java-Code
für „Trading and Pricing” erfolgreich durch Scala ersetzt. EDFT spricht von einer signifikanten Steigerung der Produktivität und von sehr viel verbesserten
Schnittstellen für ihre Händler. Der Teamleiter Alex McGuire hat mittlerweile EDFT verlassen und eine eigene Firma gegründet, die Scala-Consulting für
Finanzdienstleister und Handelsunternehmen bietet.
2. Twitter12 bietet einen sehr populären Realtime-Messaging-Service, den weltweit über 70 Millionen User nutzen. Pro Tag verarbeitet die Twitter-Infrastruktur, die mittlerweile im Backend zum Großteil aus Scala-Code besteht, über 50
Millionen Kurznachrichten, sogenannte Tweets.
Und was ist mit kommerziellem Support? Den gibt es bereits in verschiedenster
Form. Es gibt eine sehr aktive Scala-Community und erste, auch deutsche, Firmen,
die Scala-Consulting leisten. Ein wesentlicher Schritt war die Gründung der Firma ScalaSolutions durch Martin Odersky selbst. Die Firma bietet Scala-Support,
-Consulting und -Training an. Und nicht zuletzt damit können interessierte und
gute Java-Programmierer innerhalb kürzester Zeit zu guten Scala-Entwicklern geschult werden.
1.2
Java-Scala-Integration
Auch wenn Sie Scala noch nicht kennengelernt haben, wollen wir an dieser Stelle
zur weiteren Motivation bereits etwas über die nahtlose Integration mit Java sagen. Aus Scala heraus können Sie Java-Klassen und -bibliotheken genauso nutzen,
wie Sie das direkt in Java machen würden13 .
Umgekehrt geht das fast genauso einfach. Nur an ein paar kleinen Stellen müssen Sie ein bisschen mehr über die Interna wissen. Scala ist, was Sprachfeatures
angeht, mächtiger als Java. Alle Features werden aber durch Java-Bytecode repräsentiert. Daher kommen wir von Java aus überall heran, die Frage ist nur wie.
12
http://twitter.com/
Eine kleine Besonderheit stellen Javas Wildcard und Raw Types dar. Auch dafür gibt es in Scala eine
Lösung, aber die würde an dieser Stelle etwas zu weit führen. Die Lösung, existenzielle Typen, werden
wir in Abschnitt 5.7.9 besprechen.
13
1.3 Über dieses Buch
5
In Scala ist im Gegensatz zu Java alles ein Objekt. Zur besseren Performanz werden die Objekte, die in Java als primitive Typen repräsentiert werden, wenn möglich in einen primitiven Wert umgewandelt, z.B. der Scala Int in den Java int.
Ist dies nicht möglich, z.B. weil in Java primitive Datentypen nicht als Typparameter für generische Klassen zulässig sind, wird der Wert in die entsprechende
Wrapper-Instanz umgewandelt. Beispielsweise wird der Scala Int in einer Liste
in eine Instanz der Klasse java.lang.Integer übersetzt.
Scalas reine Objektorientierung lässt keine statischen Klassenmember zu. Stattdessen hat Scala Singleton-Objekte. Aus einem Singleton-Objekt mit dem Namen
MyObject wird eine Klasse mit dem Namen MyObject$ erzeugt, die das Objekt
über das statische Feld MODULE$ nutzbar macht.
Wenn es zum Singleton-Objekt keine dazugehörige Klasse gibt, es sich also um
ein sogenanntes Standalone-Objekt handelt, wird darüber hinaus noch eine Klasse mit dem Namen MyObject erzeugt, die statische Member für alle Member
des Scala-Objekts enthält. Damit wird dann auf das Member x des Scala-Objekts
MyObject in Scala wie auch in Java mit MyObject.x zugegriffen.
Mit Scalas Traits ist es ein bisschen komplizierter, da Java kein entsprechendes
Konstrukt kennt. Aus einem Trait wird immer ein Java-Interface und damit ein
Typ erzeugt. Über Variablen dieses Typs können alle Methoden der Scala-Objekte
genutzt werden. Das Implementieren eines Traits in Java ist allerdings nicht praktikabel, außer der Trait enthält nur abstrakte Member.
Javas Annotations und Exceptions werden von Scala unterstützt. Spezielle ScalaAnnotations wie zum Beispiel @volatile, @transient und @serializable
werden in die entsprechenden Java-Konstrukte transformiert. Scala kennt keine Checked Exceptions, bietet aber eine @throws-Annotation für die JavaInteroperabilität.
1.3
Über dieses Buch
Mit dem vorliegenden Buch wollen wir Sie in die faszinierende Welt von Scala entführen. Um Ihnen den Einstieg so angenehm wie möglich zu machen und
damit Sie das von uns Beschriebene gleich praktisch ausprobieren können, beginnen wir in Kapitel 2 mit Informationen über die Scala-Tools und über die Tools
zur Unterstützung des Entwicklungsprozesses.
Anschließend befassen wir uns in drei Kapiteln mit der Programmiersprache Scala. In Kapitel 3 tasten wir uns an die Syntax heran und besprechen die imperativen Programmierkonzepte. Außerdem zeigen wir Ihnen, wie in Scala ausführbare
Scripts entwickelt werden, und erstellen ein erstes kompilierbares Programm.
Auch wenn sich die Features von Scala nicht streng in Merkmale objektorientierter
und funktionaler Programmiersprachen aufteilen lassen, haben wir eine solche
Aufteilung in die beiden Kapitel 4 und 5 vorgenommen. Dabei findet sich alles,
Stichwortverzeichnis
Actor
! 197
Act 196
DaemonActor 207
Reactor 208
RemoteActor 211
ReplyReactor 208
TIMEOUT 198
actor 194
alive 211
loopWhile 205
loop 205
reactWithin 203
react 203
receiveWithin 198
receive 197
register 211
remoteActor 212
self 197
Scheduler 209
Annotation 44
deprecated 44
serializable 44
spezialized 157
tailrec 107
throws 128
transient 44
unchecked 44, 124
volatile 44
Self-Type 160
Varianz-Annotation 150
Argument
Default 36
Named 36
Array 29
args 40
Bedarfsauswertung 102
Bezeichner 31
Call-by-Name 140
Call-by-Value 139
Closure 104
Collections 170
Context Bound 155
Currysierung 132
dynamisches Binden 72
Eclipse 22
Enumeration 65
Evaluation
Eager 102
Lazy 102
Exception Handling 126
Extraktor 128
Feld 47
Filter 142
For-Comprehension 141
For-Expression 141
Funktion 35, 104
dropWhile 112
exists 112
312
filterNot 112
filter 112
flatMap 144
foldLeft 112
foldRight 112
forall 112
foreach 111
map 110
parseAll 183
partition 112
reduceLeft 113
reduceRight 113
scanLeft 113
scanRight 113
span 112
takeWhile 112
Angabe des Ergebnistyps notwendig 36
Closure 104
endrekursiv 106
höherer Ordnung 108
ineinander verschachtelte 37
Literal 104
Parameterliste 35
partiell angewendete 110
partielle 124
rekursive 104
tail recursiv 106
variable Parameteranzahl 37
Gültigkeitsbereich 41
Generator 41, 141
Higher-Order-Function 108
IDE
IntelliJ IDEA 24
NetBeans 23
Scala-IDE for Eclipse 22
Implicits 95
Import Selector Clause 81
IntelliJ IDEA 24
Interface
Rich 83
Stichwortverzeichnis
Java-Integration 29
Klasse
-Parameter 62
AnyRef 167
AnyVal 167
Any 165
Array 29, 155
ArrowAssoc 98, 169
Future 207
ListBuffer 30
List 28, 111
NodeSeq 178
ScalaObject 167
Set 34
TailCalls 107
abtrakte 73
Basis- 67
Case 119
leerer Rumpf 70
Sub- 67
Super- 67
versiegelte 122
Kommando
fsc 10, 15
javap 15
mvn 17
sbaz 10
sbt 19
scalac 10, 13
scaladoc 10, 16
scalap 10, 15
scala 9, 11
Kommentar 33
Konstruktor 62
auxiliary 63
primärer 62
zusätzlicher 63
Kontrollstruktur
do-while 40
for 41
if-else 40
while 40
eigene 135
Stichwortverzeichnis
Manifest 156
Maven-Scala-Plugin 17
Member 47
abtraktes 73
Methode 47
Überladen 55
!= 166
<fieldname>_= 50
+= 30
-> 169
== 166
andThen 125
apply 28, 59
asInstanceOf 167
assert 169
assume 169
copy 121
curried 133
equals 166
eq 168
error 169
exit 169
foreach 172
hashCode 166
isDefinedAt 125
isInstanceOf 167
iterator 172
lift 125
main 43
ne 168
orElse 125
println 170
readLine 170
require 169
r 131
toString 166
unapply 120
unary_<op> 59
update 29, 59
empty-paren 58
Extraktor- 120
Factory- 64
Getter 50
parameterless 58
313
Redefinition 50
Setter 50
Mixin 84
Nebenläufigkeit 193
NetBeans 23
Objekt
Actor 194
Predef 169
Companion- 53
Operator
<:< 158
<%< 158
+= 30
/: 113
:: 30
:> 151
:\ 113
<: 151
<% 154
=:= 158
Assoziativität 32
auf : endend 31
auf = endend 30
Cons 30
Infix 31, 59
Postfix 40, 59
Präfix 59
Priorität 32
zulässige Zeichen 32
Package 78
Package Object 79
Packages
nested 78
Parameter
By-Name- 140
implizite 98
variable Anzahl 37
Parameterliste
geschweifte Klammern 135
Parser 180
Packrat 181
partially applied function 110
314
Pattern
Case-Klassen 119
Extraktoren 128
regulärer Ausdruck 130
Teil- 126
Typ 116
Variable 116
Wildcard 115
XML 179
Pattern Matching 114
Guards 118
Polymorphie 72
Polymorphismus
parametrischer 148
Predef-Objekt 169
Property 52
Prozedur 35
Rekursion 104
REPL 10, 11
Rich-Wrapper 95
Sbt 19
Schlüsselwort 33
abstract 75
case 114, 119
catch 126
class 47
def 35
else 40
extends 67
finally 127
final 70
for 41, 141
if 40
implicit 95
import 80
lazy 102
match 114
new 28, 49, 62
object 47
override 50
package 78
private 56
protected 56
Stichwortverzeichnis
return 35
sealed 122
super 69
this 63
trait 83
try 126
type 39, 60
val 28
var 28
while 40
with 85
yield 143
Scope 41
Script 39
Self-Type-Annotation 160
Semikolon-Inferenz 27, 38
Sichtbarkeitsmodifier 56
private 56
protected 56
public 56
Companion-Objekt 57
Simple Build Tool 19
Thread 194
Trait 82
Actor 194
Application 42, 65
BitSet 175
ClassManifest 156
Functionn 104
Iterable 172
JavaTokenParsers 181
LinearSeq 173
Map 175
Ordered 87
PartialFunction 124
RegexParsers 181
Seq 173
Set 174
SortedMap 176
SortedSet 175
Traversable 172
Vector 173
Linearisierung 94
Stichwortverzeichnis
Stackable 88
Trampoline 107
Tupel 33
Zuweisung an 34
Typ
AnyRef 147
AnyVal 147
Any 147
Nothing 147
Null 147
Option 147
ScalaObject 147
Unit 35
_* 37
Bottom- 147
Boxing 157
Context Bound 155
existenzieller 162
Generalisierung 68
Generalized Type
Constraints 158
Inferenz 147
Infix-Schreibweise 148
Konstruktor 148
Lower Bound 151
parametrischer 148
parametrisierter 28
Spezialisierung 68, 157
struktureller 162
Sub- 68
Subtyp 149
Super- 68
Synonym 39, 60
Upper Bound 151
315
View Bound 154
Typinferenz 27
Typisierung 27, 147
Umgebungsvariable
JAVACMD 10
JAVA_HOME 11
JAVA_OPTS 11
Umwandlung
implizite 95
Uniform Access Principle 58
Variable
Instanz- 49
unveränderliche 28
veränderliche 28
Varianz
Annotation 150
kontravariant 150
kovariant 150
nonvariant 149
Vererbung 67
View 154
View Bound 154
XML 176
Brace Escapes 177
Literal 176
Pattern Matching 179
Zeichenkette
mehrzeilig 33
Zuweisung
gleichzeitig an mehrere
Bezeichner 34