Scala
Objekt-funktionale Programmierung
1st Edition
Published on 5. November 2010
315 pages
978-3-446-42622-1 (ISBN)
Description
DAS UMFASSENDE BUCH ZUR PROGRAMMIERUNG IN SCALA- Entdecken Sie die ganze Welt von Scala: Die Sprache, die Tools, die Bibliotheken, die Frameworks- Nutzen Sie die nachvollziehbaren Beispiele, um in der Scala-Programmierung rasch fit zu werden.- Im Internet: Der Quellcode aus dem Buch zum Download unter http://scala.obraun.netSie sind neugierig auf Scala, die neue, universale Programmiersprache, die Objektorientierung und funktionale Programmierung auf einzigartige Weise vereint? Sie wollen diese Sprache kennen lernen und erfahren, welche Vorzüge sie hat? Dann sind Sie hier richtig.Oliver Braun führt Sie detailliert in die Sprache und ihre Syntax ein und stellt die Arbeitsumgebung für die Programmierung von Scala und die Ausführung des Codes vor. Er geht auf die für die Praxis wichtigen Themen Dokumentation und Testen ein und macht Sie mit den wichtigsten Bibliotheken und Frameworks wie Lift und Akka vertraut. Besonders stark ist Scala im Bereich der nebenläufigen Programmierung, daher ist auch diesem Thema ein eigenes Kapitel gewidmet.Insgesamt erhalten Sie einen umfassenden Überblick, welche Vorzüge Scala in der Praxis tatsächlich hat und eignen sich die Sprache anhand der vielen nachvollziehbaren Beispiele rasch an.Aus dem Inhalt: Reine Objektorientierung, Funktionales Programmieren, Die Scala-Standardbibliothek, Actors - Concurrency und Multicore-Programmierung, Softwarequalität - Dokumentieren und Testen, Webprogrammierung mit Lift, Leichtgewichtige Webprogrammierung mit Scalatra, Akka - Actors und Software Transactional MemorySystemvoraussetzungen für eBook-inside: Internet-Verbindung und eBookreader Adobe Digital Editions.
More details
Other editions
Additional editions
Book
11/2010
1st Edition
Hanser
€34.90
Article exhausted; check different version
Person
Prof. Dr. Oliver Braun ist Professor für Programmierung und verteilte Systeme an der Fachhochschule Schmalkalden. Zu seinen Schwerpunkten zählt die Funktionale Programmierung. Neben seiner Hochschultätigkeit berät er Firmen zu gesamtheitlichen IuK-Konzepten.
Content
1 - Inhaltsverzeichnis [Seite 8]
2 - Vorwort [Seite 12]
3 - 1 Einführung [Seite 14]
3.1 - 1.1 Was Führungskräfte über Scala wissen sollten [Seite 16]
3.2 - 1.2 Java-Scala-Integration [Seite 17]
3.3 - 1.3 Über dieses Buch [Seite 18]
3.4 - 1.4 Typographische und sonstige Konventionen [Seite 19]
4 - 2 Einrichten der Arbeitsumgebung [Seite 22]
4.1 - 2.1 Die Scala-Shell und die Kommandozeile [Seite 22]
4.1.1 - 2.1.1 Der Scala-Interpreter [Seite 24]
4.1.2 - 2.1.2 Die Scala-(De-)Compiler [Seite 26]
4.1.3 - 2.1.3 Der Dokumentationsgenerator [Seite 29]
4.2 - 2.2 Buildtools [Seite 30]
4.2.1 - 2.2.1 Das Maven-Scala-Plugin [Seite 30]
4.2.2 - 2.2.2 Simple Build Tool [Seite 32]
4.3 - 2.3 IDE-Support [Seite 35]
4.3.1 - 2.3.1 Eclipse [Seite 35]
4.3.2 - 2.3.2 NetBeans [Seite 36]
4.3.3 - 2.3.3 IntelliJ IDEA [Seite 37]
5 - 3 Grundlagen [Seite 40]
5.1 - 3.1 Ein kleines bisschen Syntax [Seite 40]
5.2 - 3.2 Imperative Programmierung [Seite 52]
5.3 - 3.3 Ein ausführbares Programm [Seite 55]
5.4 - 3.4 Annotations [Seite 57]
6 - 4 Reine Objektorientierung [Seite 60]
6.1 - 4.1 Klassen und Objekte [Seite 60]
6.1.1 - 4.1.1 Felder und Methoden [Seite 60]
6.1.2 - 4.1.2 Was Klassen sonst noch enthalten können [Seite 73]
6.1.3 - 4.1.3 Konstruktoren [Seite 75]
6.1.4 - 4.1.4 Enumerations [Seite 78]
6.1.5 - 4.1.5 Vererbung und Subtyping [Seite 80]
6.1.6 - 4.1.6 Abstrakte Klassen [Seite 86]
6.2 - 4.2 Codeorganisation [Seite 91]
6.2.1 - 4.2.1 Packages [Seite 91]
6.2.2 - 4.2.2 Package Objects [Seite 92]
6.2.3 - 4.2.3 Importe [Seite 93]
6.3 - 4.3 Traits [Seite 95]
6.3.1 - 4.3.1 Rich Interfaces [Seite 96]
6.3.2 - 4.3.2 Stapelbare Modifikationen [Seite 101]
6.4 - 4.4 Implicits und Rich-Wrapper [Seite 108]
7 - 5 Funktionales Programmieren [Seite 114]
7.1 - 5.1 Lazy Evaluation [Seite 115]
7.2 - 5.2 Funktionen und Rekursionen [Seite 117]
7.3 - 5.3 Higher-Order-Functions [Seite 121]
7.4 - 5.4 Case-Klassen und Pattern Matching [Seite 127]
7.4.1 - 5.4.1 Case-Klassen [Seite 132]
7.4.2 - 5.4.2 Versiegelte Klassen [Seite 135]
7.4.3 - 5.4.3 Partielle Funktionen [Seite 137]
7.4.4 - 5.4.4 Variablennamen für (Teil-)Pattern [Seite 139]
7.4.5 - 5.4.5 Exception Handling [Seite 139]
7.4.6 - 5.4.6 Extraktoren [Seite 141]
7.4.7 - 5.4.7 Pattern Matching mit regulären Ausdrücken [Seite 143]
7.5 - 5.5 Currysierung und eigene Kontrollstrukturen [Seite 145]
7.6 - 5.6 For-Expressions [Seite 154]
7.7 - 5.7 Typsystem [Seite 160]
7.7.1 - 5.7.1 Standardtypen [Seite 160]
7.7.2 - 5.7.2 Parametrischer Polymorphismus und Varianz [Seite 161]
7.7.3 - 5.7.3 Upper und Lower Bounds [Seite 164]
7.7.4 - 5.7.4 Views und View Bounds [Seite 167]
7.7.5 - 5.7.5 Context Bounds [Seite 168]
7.7.6 - 5.7.6 Arrays und @specialized [Seite 168]
7.7.7 - 5.7.7 Generalized Type Constraints [Seite 171]
7.7.8 - 5.7.8 Self-Type-Annotation [Seite 173]
7.7.9 - 5.7.9 Strukturelle und existenzielle Typen [Seite 175]
8 - 6 Die Scala-Standardbibliothek [Seite 178]
8.1 - 6.1 Überblick und das Predef-Objekt [Seite 178]
8.2 - 6.2 Das Collection-Framework [Seite 183]
8.3 - 6.3 Scala und XML [Seite 189]
8.4 - 6.4 Parser kombinieren [Seite 193]
8.5 - 6.5 Ein kleines bisschen GUI [Seite 200]
9 - 7 Actors - Concurrency und Multicore-Programmierung [Seite 206]
9.1 - 7.1 Ein Thread ist ein Actor [Seite 207]
9.2 - 7.2 Empfangen und Reagieren [Seite 209]
9.3 - 7.3 Dämonen und Reaktoren [Seite 220]
9.4 - 7.4 Scheduler [Seite 222]
9.5 - 7.5 Remote Actors [Seite 224]
10 - 8 Softwarequalität - Dokumentieren und Testen [Seite 228]
10.1 - 8.1 Scaladoc [Seite 229]
10.2 - 8.2 ScalaCheck [Seite 234]
10.2.1 - 8.2.1 Grundlagen [Seite 234]
10.2.2 - 8.2.2 Generatoren [Seite 237]
10.2.3 - 8.2.3 Automatisiertes Testen mit Sbt [Seite 242]
10.3 - 8.3 ScalaTest [Seite 245]
10.3.1 - 8.3.1 ScalaTest und JUnit [Seite 246]
10.3.2 - 8.3.2 ScalaTest und TestNG [Seite 248]
10.3.3 - 8.3.3 ScalaTest und BDD [Seite 249]
10.3.4 - 8.3.4 Funktionale, Integrations- und Akzeptanztests [Seite 251]
10.3.5 - 8.3.5 Die FunSuite [Seite 253]
10.4 - 8.4 Specs [Seite 254]
10.4.1 - 8.4.1 Eine Specs-Spezifikation [Seite 255]
10.4.2 - 8.4.2 Matchers [Seite 257]
10.4.3 - 8.4.3 Mocks mit Mockito [Seite 261]
10.4.4 - 8.4.4 Literate Specifications [Seite 262]
11 - 9 Webprogrammierung mit Lift [Seite 266]
11.1 - 9.1 Quickstart mit Lift [Seite 267]
11.2 - 9.2 Bootstrapping [Seite 270]
11.3 - 9.3 Rendering - Templates und Snippets [Seite 275]
11.4 - 9.4 Benutzerverwaltung und SiteMap [Seite 277]
11.5 - 9.5 Persistenz [Seite 279]
11.6 - 9.6 Implementierung der Snippets [Seite 282]
12 - 10 Leichtgewichtige Webprogrammierung mit Scalatra [Seite 292]
12.1 - 10.1 Quickstart mit Scalatra [Seite 292]
12.2 - 10.2 Der Final-Grade-Calculator [Seite 294]
13 - 11 Akka - Actors und Software Transactional Memory [Seite 300]
13.1 - 11.1 Quickstart mit Akka [Seite 301]
13.2 - 11.2 Der MovieStore [Seite 302]
13.3 - 11.3 User- und Session-Management [Seite 306]
13.4 - 11.4 Software Transactional Memory [Seite 310]
13.5 - 11.5 Client und Service [Seite 313]
14 - Schlusswort [Seite 318]
15 - Literaturverzeichnis [Seite 320]
16 - Stichwortverzeichnis [Seite 324]
2 - Vorwort [Seite 12]
3 - 1 Einführung [Seite 14]
3.1 - 1.1 Was Führungskräfte über Scala wissen sollten [Seite 16]
3.2 - 1.2 Java-Scala-Integration [Seite 17]
3.3 - 1.3 Über dieses Buch [Seite 18]
3.4 - 1.4 Typographische und sonstige Konventionen [Seite 19]
4 - 2 Einrichten der Arbeitsumgebung [Seite 22]
4.1 - 2.1 Die Scala-Shell und die Kommandozeile [Seite 22]
4.1.1 - 2.1.1 Der Scala-Interpreter [Seite 24]
4.1.2 - 2.1.2 Die Scala-(De-)Compiler [Seite 26]
4.1.3 - 2.1.3 Der Dokumentationsgenerator [Seite 29]
4.2 - 2.2 Buildtools [Seite 30]
4.2.1 - 2.2.1 Das Maven-Scala-Plugin [Seite 30]
4.2.2 - 2.2.2 Simple Build Tool [Seite 32]
4.3 - 2.3 IDE-Support [Seite 35]
4.3.1 - 2.3.1 Eclipse [Seite 35]
4.3.2 - 2.3.2 NetBeans [Seite 36]
4.3.3 - 2.3.3 IntelliJ IDEA [Seite 37]
5 - 3 Grundlagen [Seite 40]
5.1 - 3.1 Ein kleines bisschen Syntax [Seite 40]
5.2 - 3.2 Imperative Programmierung [Seite 52]
5.3 - 3.3 Ein ausführbares Programm [Seite 55]
5.4 - 3.4 Annotations [Seite 57]
6 - 4 Reine Objektorientierung [Seite 60]
6.1 - 4.1 Klassen und Objekte [Seite 60]
6.1.1 - 4.1.1 Felder und Methoden [Seite 60]
6.1.2 - 4.1.2 Was Klassen sonst noch enthalten können [Seite 73]
6.1.3 - 4.1.3 Konstruktoren [Seite 75]
6.1.4 - 4.1.4 Enumerations [Seite 78]
6.1.5 - 4.1.5 Vererbung und Subtyping [Seite 80]
6.1.6 - 4.1.6 Abstrakte Klassen [Seite 86]
6.2 - 4.2 Codeorganisation [Seite 91]
6.2.1 - 4.2.1 Packages [Seite 91]
6.2.2 - 4.2.2 Package Objects [Seite 92]
6.2.3 - 4.2.3 Importe [Seite 93]
6.3 - 4.3 Traits [Seite 95]
6.3.1 - 4.3.1 Rich Interfaces [Seite 96]
6.3.2 - 4.3.2 Stapelbare Modifikationen [Seite 101]
6.4 - 4.4 Implicits und Rich-Wrapper [Seite 108]
7 - 5 Funktionales Programmieren [Seite 114]
7.1 - 5.1 Lazy Evaluation [Seite 115]
7.2 - 5.2 Funktionen und Rekursionen [Seite 117]
7.3 - 5.3 Higher-Order-Functions [Seite 121]
7.4 - 5.4 Case-Klassen und Pattern Matching [Seite 127]
7.4.1 - 5.4.1 Case-Klassen [Seite 132]
7.4.2 - 5.4.2 Versiegelte Klassen [Seite 135]
7.4.3 - 5.4.3 Partielle Funktionen [Seite 137]
7.4.4 - 5.4.4 Variablennamen für (Teil-)Pattern [Seite 139]
7.4.5 - 5.4.5 Exception Handling [Seite 139]
7.4.6 - 5.4.6 Extraktoren [Seite 141]
7.4.7 - 5.4.7 Pattern Matching mit regulären Ausdrücken [Seite 143]
7.5 - 5.5 Currysierung und eigene Kontrollstrukturen [Seite 145]
7.6 - 5.6 For-Expressions [Seite 154]
7.7 - 5.7 Typsystem [Seite 160]
7.7.1 - 5.7.1 Standardtypen [Seite 160]
7.7.2 - 5.7.2 Parametrischer Polymorphismus und Varianz [Seite 161]
7.7.3 - 5.7.3 Upper und Lower Bounds [Seite 164]
7.7.4 - 5.7.4 Views und View Bounds [Seite 167]
7.7.5 - 5.7.5 Context Bounds [Seite 168]
7.7.6 - 5.7.6 Arrays und @specialized [Seite 168]
7.7.7 - 5.7.7 Generalized Type Constraints [Seite 171]
7.7.8 - 5.7.8 Self-Type-Annotation [Seite 173]
7.7.9 - 5.7.9 Strukturelle und existenzielle Typen [Seite 175]
8 - 6 Die Scala-Standardbibliothek [Seite 178]
8.1 - 6.1 Überblick und das Predef-Objekt [Seite 178]
8.2 - 6.2 Das Collection-Framework [Seite 183]
8.3 - 6.3 Scala und XML [Seite 189]
8.4 - 6.4 Parser kombinieren [Seite 193]
8.5 - 6.5 Ein kleines bisschen GUI [Seite 200]
9 - 7 Actors - Concurrency und Multicore-Programmierung [Seite 206]
9.1 - 7.1 Ein Thread ist ein Actor [Seite 207]
9.2 - 7.2 Empfangen und Reagieren [Seite 209]
9.3 - 7.3 Dämonen und Reaktoren [Seite 220]
9.4 - 7.4 Scheduler [Seite 222]
9.5 - 7.5 Remote Actors [Seite 224]
10 - 8 Softwarequalität - Dokumentieren und Testen [Seite 228]
10.1 - 8.1 Scaladoc [Seite 229]
10.2 - 8.2 ScalaCheck [Seite 234]
10.2.1 - 8.2.1 Grundlagen [Seite 234]
10.2.2 - 8.2.2 Generatoren [Seite 237]
10.2.3 - 8.2.3 Automatisiertes Testen mit Sbt [Seite 242]
10.3 - 8.3 ScalaTest [Seite 245]
10.3.1 - 8.3.1 ScalaTest und JUnit [Seite 246]
10.3.2 - 8.3.2 ScalaTest und TestNG [Seite 248]
10.3.3 - 8.3.3 ScalaTest und BDD [Seite 249]
10.3.4 - 8.3.4 Funktionale, Integrations- und Akzeptanztests [Seite 251]
10.3.5 - 8.3.5 Die FunSuite [Seite 253]
10.4 - 8.4 Specs [Seite 254]
10.4.1 - 8.4.1 Eine Specs-Spezifikation [Seite 255]
10.4.2 - 8.4.2 Matchers [Seite 257]
10.4.3 - 8.4.3 Mocks mit Mockito [Seite 261]
10.4.4 - 8.4.4 Literate Specifications [Seite 262]
11 - 9 Webprogrammierung mit Lift [Seite 266]
11.1 - 9.1 Quickstart mit Lift [Seite 267]
11.2 - 9.2 Bootstrapping [Seite 270]
11.3 - 9.3 Rendering - Templates und Snippets [Seite 275]
11.4 - 9.4 Benutzerverwaltung und SiteMap [Seite 277]
11.5 - 9.5 Persistenz [Seite 279]
11.6 - 9.6 Implementierung der Snippets [Seite 282]
12 - 10 Leichtgewichtige Webprogrammierung mit Scalatra [Seite 292]
12.1 - 10.1 Quickstart mit Scalatra [Seite 292]
12.2 - 10.2 Der Final-Grade-Calculator [Seite 294]
13 - 11 Akka - Actors und Software Transactional Memory [Seite 300]
13.1 - 11.1 Quickstart mit Akka [Seite 301]
13.2 - 11.2 Der MovieStore [Seite 302]
13.3 - 11.3 User- und Session-Management [Seite 306]
13.4 - 11.4 Software Transactional Memory [Seite 310]
13.5 - 11.5 Client und Service [Seite 313]
14 - Schlusswort [Seite 318]
15 - Literaturverzeichnis [Seite 320]
16 - Stichwortverzeichnis [Seite 324]
"Kapitel 7 Actors – Concurrency und Multicore-Programmierung (S. 193-194)
Nebenläufige Programmierung insbesondere unter Nutzung mehrerer Cores wird immer mehr zur Standardaufgabe für Softwareentwickler. Das liegt daran, dass die Prozessoren nicht mehr schneller werden, sondern dass sich in einem Prozessor immer mehr Kerne befinden. Ein Prozessor mit sehr wenigen Kernen kann in der Regel durch Betriebssystemprozesse noch ganz ordentlich ausgenutzt werden. Nun können z.B. zwei Prozesse, die sonst abwechselnd rechnen durften, parallel arbeiten.
Werden es aber immer mehr Kerne, wird es essenziell notwendig, die Programme selbst in mehrere Prozesse oder Threads aufzuteilen. Nachdem Scala auf der Java Virtual Machine oder auf einer .NET-Runtime ausgeführt wird, ist natürlich alles aus Java bzw. .NET verfügbar, um nebenläufig (engl. concurrent) zu programmieren. Scala bietet aber noch eine weitere, sehr elegante Abstraktionsmöglichkeit, die auf einem mathematischen Modell von nebenläufi- ger Programmierung basiert: die Actors1.
Es gibt Implementierungen des Actor-Modells in einigen Programmiersprachen bis hin zu actorbasierten, general purpose Programmiersprachen wie z.B. ActorScript2. Die Scala-Implementierung lehnt sich von der Syntax stark an die Actor- Implementierung in der funktionalen Programmiersprache Erlang3 an. Actors sind ganz nach der Scala-Philosophie nicht im Sprachkern, sondern als Library im Package scala.actors verfügbar.
Die Grundidee des Actor-Modells ist, dass ein Actor mit anderen Actors nur über Messages kommuniziert. Wird einem Actor eine Message gesendet, landet diese in seiner Mailbox und bleibt dort, bis der Actor sie herausnimmt. Das heißt also, die Kommunikation ist grundsätzlich asynchron4. In diesem Kapitel geben wir Ihnen eine Einführung in die Welt der Scala-Actors. Wir beginnen in Abschnitt 7.1 damit, den Zusammenhang zwischen Actors und Threads zu erläutern. Wie ein Actor Messages empfangen und darauf reagieren kann, wird in Abschnitt 7.2 dargestellt. Besondere Aktoren, nämlich Reaktoren und Dämonen, sind Gegenstand von Abschnitt 7.3. Für Aktoren wird ein Scheduling benötigt. Informationen darüber finden Sie in Abschnitt 7.4. Das Kapitel schließt mit einem Blick auf Remote Actors (siehe Abschnitt 7.5)."
Nebenläufige Programmierung insbesondere unter Nutzung mehrerer Cores wird immer mehr zur Standardaufgabe für Softwareentwickler. Das liegt daran, dass die Prozessoren nicht mehr schneller werden, sondern dass sich in einem Prozessor immer mehr Kerne befinden. Ein Prozessor mit sehr wenigen Kernen kann in der Regel durch Betriebssystemprozesse noch ganz ordentlich ausgenutzt werden. Nun können z.B. zwei Prozesse, die sonst abwechselnd rechnen durften, parallel arbeiten.
Werden es aber immer mehr Kerne, wird es essenziell notwendig, die Programme selbst in mehrere Prozesse oder Threads aufzuteilen. Nachdem Scala auf der Java Virtual Machine oder auf einer .NET-Runtime ausgeführt wird, ist natürlich alles aus Java bzw. .NET verfügbar, um nebenläufig (engl. concurrent) zu programmieren. Scala bietet aber noch eine weitere, sehr elegante Abstraktionsmöglichkeit, die auf einem mathematischen Modell von nebenläufi- ger Programmierung basiert: die Actors1.
Es gibt Implementierungen des Actor-Modells in einigen Programmiersprachen bis hin zu actorbasierten, general purpose Programmiersprachen wie z.B. ActorScript2. Die Scala-Implementierung lehnt sich von der Syntax stark an die Actor- Implementierung in der funktionalen Programmiersprache Erlang3 an. Actors sind ganz nach der Scala-Philosophie nicht im Sprachkern, sondern als Library im Package scala.actors verfügbar.
Die Grundidee des Actor-Modells ist, dass ein Actor mit anderen Actors nur über Messages kommuniziert. Wird einem Actor eine Message gesendet, landet diese in seiner Mailbox und bleibt dort, bis der Actor sie herausnimmt. Das heißt also, die Kommunikation ist grundsätzlich asynchron4. In diesem Kapitel geben wir Ihnen eine Einführung in die Welt der Scala-Actors. Wir beginnen in Abschnitt 7.1 damit, den Zusammenhang zwischen Actors und Threads zu erläutern. Wie ein Actor Messages empfangen und darauf reagieren kann, wird in Abschnitt 7.2 dargestellt. Besondere Aktoren, nämlich Reaktoren und Dämonen, sind Gegenstand von Abschnitt 7.3. Für Aktoren wird ein Scheduling benötigt. Informationen darüber finden Sie in Abschnitt 7.4. Das Kapitel schließt mit einem Blick auf Remote Actors (siehe Abschnitt 7.5)."
