Cover image for Programmieren mit Scala

Book description

Scala ist eine neue Programmiersprache für die Java Virtual Machine (JVM), mit der sich verschiedene Programmierparadigmen verwirklichen lassen, unter anderem das funktionale Programmieren. Mit diesem Buch lernen Sie, wie Sie Scala produktiv einsetzen, und warum sich Scala so ideal für skalierbare, komponenenbasierte Anwendungen eignet, die Nebenläufigkeit unterstützen. Sie erfahren auch, wie Sie Javas mächtige Klassenbibliotheken nutzen, um die praktischen Anforderungen Ihrer Enterprise- und Webanwendungen leichter umzusetzen.

Table of Contents

  1. Programmieren mit Scala
  2. Zum Geleit
  3. Vorwort
    1. Willkommen zu Programmieren mit Scala
    2. Im Buch verwendete Konventionen
    3. Verwendung der Codebeispiele
      1. Codebeispiele herunterladen
    4. Danksagungen
  4. 1. Von null auf hundert: Scala kennenlernen
    1. Warum Scala?
      1. Wenn Sie Java programmieren …
      2. Wenn Sie Ruby, Python usw. programmieren …
      3. Was ist Scala?
      4. Was Scala so verführerisch macht
    2. Scala installieren
    3. Weitere Informationen
    4. Eine Kostprobe Scala
    5. Ein Häppchen Nebenläufigkeit
    6. Zusammenfassung und Ausblick
  5. 2. Weniger tippen, mehr erreichen
    1. Zu diesem Kapitel
    2. Das Semikolon
    3. Variablen deklarieren
    4. Methoden deklarieren
      1. Vorbelegte und benannte Argumente
      2. Verschachtelte Methodendefinitionen
    5. Inferenz
    6. Literale
      1. Ganzzahlige Literale
      2. Literale für Fließkommazahlen
      3. Boolesche Literale
      4. Zeichenliterale
      5. Stringliterale
      6. Symbolliterale
    7. Tupel
    8. Option, Some und None: Wie man Nullwerte vermeidet
    9. Den Code in Dateien und Namensräume organisieren
    10. Typen und ihre Member importieren
      1. Imports sind relativ
    11. Abstrakte Typen und parametrisierte Typen
    12. Reservierte Wörter
    13. Zusammenfassung und Ausblick
  6. 3. Ein paar Grundlagen fehlen noch
    1. Operatoren
      1. Syntaktische Leckerbissen
    2. Methoden ohne Klammern und Punkte
      1. Präzedenzregeln
    3. Domainspezfische Sprachen
    4. Die if-Anweisung
    5. Die for-Comprehension
      1. Ein einfaches Beispiel
      2. Filtern
      3. Yield
      4. Erweiterter Gültigkeitsbereich
    6. Weitere Schleifenkonstrukte
      1. while-Schleifen
      2. do-while-Schleifen
      3. Generatorausdrücke
    7. Bedingungsoperatoren
    8. Pattern-Matching
      1. Ein einfacher Mustervergleich
      2. Matching mit Variablen
      3. Typübereinstimmung
      4. Matching mit Sequenzen
      5. Matching mit Tupeln (und Guards)
      6. Matching mit Case-Klassen
      7. Matching mit regulären Ausdrücken
      8. Verschachtelte Variablen binden
      9. try-, catch- und finally-Klauseln verwenden
      10. Abschließende Bemerkungen zum Pattern-Matching
    9. Enumerationen
    10. Zusammenfassung und Ausblick
  7. 4. Traits
    1. Einführung in Traits
      1. Traits als Mixins
    2. Stapelbare Traits
    3. Traits konstruieren
      1. Klasse oder Trait?
    4. Zusammenfassung und Ausblick
  8. 5. Elementare objektorientierte Programmierung in Scala
    1. Klassen und Objekte
    2. Elternklassen
    3. Konstruktoren
      1. Konstruktoren der Elternklasse aufrufen
    4. Verschachtelte Klassen
    5. Sichtbarkeitsregeln
      1. Öffentliche Sichtbarkeit
      2. Geschützte Sichtbarkeit
      3. Private Sichtbarkeit
      4. Gültigkeitsbereich-private und -geschützte Sichtbarkeit
      5. Abschließende Gedanken zur Sichtbarkeit
    6. Zusammenfassung und Ausblick
  9. 6. Fortgeschrittene objektorientierte Programmierung in Scala
    1. Member von Klassen und Traits überschreiben
      1. Der Versuch, eine finale Deklaration zu überschreiben
      2. Abstrakte und konkrete Methoden überschreiben
      3. Abstrakte und konkrete Felder überschreiben
      4. Abstrakte und konkrete Felder in Traits überschreiben
      5. Abstrakte und konkrete Felder in Klassen überschreiben
      6. Abstrakte Typen überschreiben
      7. Wenn Zugriffsmethoden und Felder nicht unterscheidbar sind: Das Prinzip des einheitlichen Zugriffs
    2. Begleitobjekte
      1. Apply
      2. Unapply
      3. Apply und UnapplySeq für Kollektionen
    3. Case-Klassen
      1. Syntaktischer Süßstoff für binäre Operationen
      2. Die copy-Methode
      3. Vererbung von Case-Klassen
    4. Gleichheit von Objekten
      1. Die Methode equals
      2. Die Methoden == und !=
      3. Die Methoden ne und eq
      4. Array-Gleichheit und die Methode sameElements
    5. Zusammenfassung und Ausblick
  10. 7. Das Objektsystem in Scala
    1. Das Predef-Objekt
    2. Klassen und Objekte: Was ist aus »static« geworden?
      1. Package-Objekte
    3. Versiegelte Klassenhierarchien
    4. Die Typhierarchie von Scala
    5. Linearisierung der Objekthierarchie
    6. Zusammenfassung und Ausblick
  11. 8. Funktionale Programmierung in Scala
    1. Was ist funktionale Programmierung?
      1. Funktionen in der Mathematik
      2. Variablen, die nicht variabel sind
    2. Funktionale Programmierung in Scala
      1. Funktionsliterale und Closures
      2. Innere und äußere Reinheit
    3. Rekursion
    4. Tail-Calls und Tail-Call-Optimierung
      1. Ein Trampolin für Tail-Calls
    5. Funktionale Datenstrukturen
      1. Listen in der funktionalen Programmierung
      2. Maps in der funktionalen Programmierung
      3. Sets in der funktionalen Programmierung
      4. Andere Datenstrukturen in der funktionalen Programmierung
    6. Traversieren, abbilden, filtern, falten und reduzieren
      1. Traversierung
      2. Abbilden
      3. Filtern
      4. Falten und Reduzieren
      5. Funktionale Optionen
    7. Pattern-Matching
    8. Partielle Funktionen
    9. Currying
    10. Implizite Definitionen
      1. Implizite Konvertierungen
      2. Implizite Funktionsparameter
      3. Abschließende Gedanken zum Schlüsselwort implicit
    11. Call-by-name, Call-by-value
    12. Verzögerte Initialisierung
    13. Zusammenfassung: Abstraktionen funktionaler Komponenten
  12. 9. Robuste, skalierbare Nebenläufigkeit mit Aktoren
    1. Das Problem des gemeinsamen synchronisierten Zustands
    2. Aktoren
    3. Aktoren in Scala
      1. Nachrichten an Aktoren senden
      2. Aktoren im Detail
      3. Effektive Aktoren
    4. Traditionelle Nebenläufigkeit in Scala: Threading und Events
      1. Einmalthreads
      2. Mit java.util.concurrent arbeiten
      3. Events
    5. Zusammenfassung und Ausblick
  13. 10. Aufzucht und Pflege von XML
    1. XML lesen
      1. XML untersuchen
      2. XML-Code durchlaufen und matchen
    2. XML schreiben
      1. Ein Beispiel aus der Wirklichkeit
    3. Zusammenfassung und Ausblick
  14. 11. Domainspezifische Sprachen
    1. Interne DSLs
      1. Eine interne DSL für Gehaltsberechungen
      2. Infixoperatoren
      3. Implizite Konvertierungen und benutzerdefinierte Typen
      4. Apply-Methoden
      5. Implementierung der DSL für die Regeln der Gehaltsberechnung
      6. Interne DSLs: Abschließende Erwägungen
    2. Externe DSLs mit Parserkombinatoren
      1. Über Parserkombinatoren
      2. Eine externe DSL für Gehaltsberechnungen
      3. Eine Scala-Implementierung der externen DSL-Grammatik
      4. Mit der externen DSL Gehaltsabrechnungen generieren
      5. Interne oder externe DSLs: Abschließende Überlegungen
    3. Zusammenfassung und Ausblick
  15. 12. Das Scala-Typsystem
    1. Reflexionen über Typen
    2. Parametrisierte Typen
      1. Manifeste
      2. Parametrisierte Methoden
    3. Varianz bei Vererbung
      1. Varianz bei mutablen Typen
      2. Varianz in Scala und in Java
      3. Anmerkungen zur Implementierung
    4. Typgrenzen
      1. Typobergrenzen
      2. Typuntergrenzen
      3. Listen aus der Nähe betrachtet
      4. Views und View-Begrenzungen
    5. Null und Nothing
    6. Abstrakte Typen verstehen
      1. Parametrisierte Typen kontra abstrakte Typen
    7. Pfadabhängige Typen
      1. C.this
      2. C.super
      3. path.x
    8. Werttypen
      1. Typbezeichner
      2. Tupel
      3. Parametrisierte Typen
      4. Annotierte Typen
      5. Zusammengesetzte Typen
      6. Infixtypen
      7. Funktionstypen
      8. Typprojektionen
      9. Singleton-Typen
    9. Self-Typ-Annotationen
    10. Strukturtyp
    11. Existenzielle Typen
    12. Infinite Datenstrukturen und Trägheit
    13. Zusammenfassung und Ausblick
  16. 13. Anwendungsdesign
    1. Annotationen
    2. Enumerationen oder Pattern-Matching verwenden
    3. Überlegungen zu Annotationen und Enumerationen
      1. Pattern-Matching mit Enumerationen oder Case-Klassen
    4. Nullwerte oder Optionen verwenden
      1. Optionen und For-Comprehensions
    5. Exceptions und ihre Alternativen
    6. Skalierbare Abstraktionen
      1. Feingranulare Sichtbarkeitsregeln
      2. Mixin-Komposition
      3. Self-Typ-Annotationen und abstrakte Typmember
    7. Effektives Trait-Design
    8. Entwurfsmuster
      1. Das Visitor-Pattern: Eine bessere Möglichkeit
      2. Dependency-Injection in Scala: Das Cake-Pattern
    9. Bessere Designs durch Design by Contract
    10. Zusammenfassung und Ausblick
  17. 14. Werkzeuge, Bibliotheken und Unterstützung durch IDEs
    1. Befehlszeilenwerkzeuge
      1. scalac
      2. scala
        1. Beschränkungen von scala gegenüber scalac
      3. scalap, javap und jad
      4. scaladoc
      5. sbaz
      6. fsc
    2. Build-Tools
    3. Integration mit Entwicklungsumgebungen
      1. Eclipse
        1. Das Scala-Plugin installieren
        2. Scala-Anwendungen entwickeln
      2. IntelliJ
        1. Die Scala-Plugins installieren
        2. Scala-Anwendungen entwickeln
      3. NetBeans
        1. Die Scala-Plugins installieren
        2. Scala-Anwendungen entwickeln
      4. Texteditoren
    4. Testgetriebene Entwicklung in Scala
      1. ScalaTest
      2. Specs
      3. ScalaCheck
    5. Andere bemerkenswerte Scala-Bibliotheken und -Werkzeuge
      1. Lift
      2. Scalaz
      3. JavaRebel
      4. Diverse kleinere Bibliotheken
    6. Interoperabilität mit Java
      1. Java- und Scala-Generics
      2. Scala-Funktionen in Java verwenden
      3. JavaBean-Properties
      4. AnyVal-Typen und primitive Java-Typen
      5. Scala-Namen im Java-Code
    7. Interoperabilität mit Java-Bibliotheken
      1. AspectJ
      2. Das Spring-Framework
      3. Terracotta
      4. Hadoop
    8. Zusammenfassung und Ausblick
  18. A. Quellenverzeichnis
  19. Glossar
  20. Index
  21. Colophon