Scala 101: Einführung

• Integriert. Scalacode kann auf der Java VM ausgeführt werden. Mit Scala können bisheriger Java-Quellcode weiterverwendet werden. Statt das Rad neu zu erfinden setzt Scala auf etablierte Technologien auf.
  

• Objektorientiert. Scala ist eine objektorientierte Programmiersprache. Die Möglichkeiten gehen jedoch über die von beispielsweise Java hinaus.
  

• Funktional und Imperativ. Scala vereint Aspekte der funktionalen und imperativen Programmierung unter einem Dach. Der Programmierer kann je nach Aufgabe verschiedene Schwerpunkte in der Verwendung der Sprachmerkmale setzen.
  

• Kompakt. Typischer Scala-Quellcode ist kürzer als der entsprechende Java-Quellcode. Dies erspart dem Programmierer Schreib- und Leseaufwand. Zum besseren Verständnis kann jedoch auch ausführlicherer Quellcode geschrieben werden; etwa in komplexen Programmteilen.
  

• Erweiterbar. Scalas Syntax ist so entworfen worden, dass leicht Erweiterungen erstellt werden können, die sich in die Sprache integrieren. Mit der Sprache können Konstrukte erstellt werden, die den Schlüsselwörtern der Sprache ähneln. Scala eignet sich gut zur Erstellung von domänenspezifischen Sprachen (DSLs).
  

Scalas Syntax ist zum einen prägnant und zum anderen mächtig. Im Vergleich mit Java muss weniger Quellcode geschrieben werden, um die gleiche Idee zu verwirklichen.

Beispiel 2. Ausgabe der Primzahlen zwischen 1 und 100

object SyntaxDemo {
  def isPrime(n: Int) = (1 to n).toList.count(n % _ == 0) == 2

  def main(args: Array[String]): Unit =
        (1 to 100).filter(isPrime).foreach(println)
}

	Anmerkung
	Es gibt natürlich wesentlich bessere Mehoden zum Finden von Primzahlen als diese naive Implementierung. Das Beispiel soll zeigen, dass es möglich ist verständlichen und im Vergleich mit Java kürzeren Quellcode zu schreiben.

Scala ist eine typsichere Sprache. Das bedeutet, dass für Variable, Parameter, usw. Typen festgelegt werden müssen. Oft ist eine solche Angabe jedoch redundant und könnte weggelassen werden. In Scala brauchen Sie nur noch die nötigsten Typangaben, Scala vervollständigt die ausgelassenen Angaben automatisch selbst. Diese Eigenschaft wird als Typfolgerung (engl. type inference bezeichnet).

val v = "Hey, Scala knows that I'm a String"
println(v) 

Auf Wunsch können die optionalen Typangaben ausgeschrieben werden. Dies verbessert in komplizierten Programmteilen die Lesbarkeit. Außerdem hilft es dem Compiler die Typen komplexer Ausdrücke zu bestimmen.

val v : String = "Hey, Scala knows that I'm a String"
println(v) 

In Java gibt es Klassen und Schnittstellen. In Scala gibt es Klassen, Module und Traits.

Die sogenannte "case class" ist eine Vereinfachung bestimmter Anwendungsfälle von Klassen. Oft werden Klassen benötigt, die bestimmte Eigenschaften für den lesenden Zugriff zur Verfügung stellen und bestimmte Operationen für diese Daten anbieten.

public class JavaPerson{
    private final String firstname;
    private final String lastname;

    public JavaPerson(String firstname, String lastname) {
        this.firstname = firstname;
        this.lastname = lastname;
    }

    public String getFirstname() {
        return firstname;
    }

    public String getLastname() {
        return lastname;
    }
} 

Die obige Java-Klasse kann in einem Scala-Programm durch eine einfache case class ersetzt werden. Die folgende Klasse hat die gleiche Funktionalität wie die obige Java-Klasse:

case class ScalaPerson(firstname:String, lastname:String)
                        

In funktionalen Programmiersprachen spielen Funktionen eine zentrale Rolle. In imperativen Sprachen wie Java nehmen Daten diese Rolle ein. Scala verbindet beide Welten miteinander.

Scala erlaubt es, Funktionen zu referenzieren. Sie können beispielsweise als Parameter an andere Funktionen übergeben werden. Anonyme Funktionen sind ebenfalls möglich. Das folgende Beispiel demonstriert die Verwendung von Funktionen in Scala:

object FoodDemo {
  val food = "Bananas" :: "Bred" :: "Orange juice" :: Nil

  def main(args:Array[String]) = {
    food.foreach(thing => println("Please buy " + thing))
  }
}
                        

Das Konstrukt thing => println("Please buy " + thing) ist eine (anonyme) Funktion, die für jedes Element der Liste food aufgerufen wird. Die Ausgabe des Programms ist:

Please buy Bananas
Please buy Bred
Please buy Orange juice
                    

Scalas Standardbibliothek verfügt über ein elegantes Konzept zur parallelen Programmierung. Zwischen verschiedenen Akteueren werden Nachrichten hin- und hergeschickt. Die Nachrichten an einen Teilnehmer werden gesammelt und von diesem der Reihe nach abgarbeitet. Die Nachrichtenverarbeitung von zwei verschiedenen Akteueren kann parallel erfolgen.

Interessant ist, dass hier normalerweise keine Locks benötigt werden. Dies reduziert die Fehleranfälligkeit. Außerdem ist es so sehr einfach ein ereignisgesteuertes Programm zu erstellen.

case class Add(n:Int)
case class Substract(n:Int)
case class Print()
case class Shutdown()

class CalculatingActor extends Actor {
  import Actor._

  var result : Int = 0

  def act() = loop{
    react{
      case Add(n:Int) => result = result + n
      case Substract(n:Int) =>  result = result - n
      case Print() => println(result)
      case Shutdown() => exit()
    }
  }
} 

Dieser simple actor zeigt, wie Scalas Akteurskonzept die Entwicklung von asynchronen, nachrichtenbasierten Systeme vereinfachen kann. Im Beispiel werden Rechenaufträge erteilt, die asynchron ausgeführt werden.

Die folgenden Webseiten enthalten wichtige Informationen zum Thema Scala bzw. zu verwandten Themen.

Dies ist eine Auflistung der Bücher, die zu Scala verfügbar sind. Einige der Bücher sind noch in der Entstehung. Sie werden jedoch bald verfügbar sein.