scala – Schulung Tag 1

Hallo,

momentan bin ich dabei eine neue Programmiersprache zu lernen: scala.
Und zwar befinde ich mich auf einer Schulung in Zürich. Daher möchte ich euch natürlich an meine Erkenntnissen teilhaben lassen.
Und klar, es kann natürlich nicht die Inhalte des Kurses wiedergeben und nur ne Zusammenfassung sein.
Ich hoffe, dass es einigermaßen verständlich ist. Ansonsten gerne nachfragen, ich werden dann mein Möglichestes tun…

Was ist Scala?

  • OO und funktionale Programmiersprache auf der JVM

Warum ist Scala denn so toll?

  • Kürzere Syntax als Java
  • class Time( val hours: Int, val minutes: Int) erzeugt ne Klasse mit zwei Properties
  •  Nette Sprachfeatures
  •  val numbers = 1 to 10 erzeugt ne Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
  • Java Klassen lassen sich benutzen

Was brauche ich für Scala?

  • Scala Interpreter
  • Java
  • IDE (Eclipse, Netbeans, IntelliJ, …)

Hello World in scala
[code]
object Hello {
def main(args: Array[String]) {
println( „Hello World!“)
}
}
[/code]

Es gibt mit sbt eine Art Mischung aus ant und maven für scala.

scala besitzt zwei Typen von Variablen:

  • val sind unveränderlich
  • var sind veränderlich

Es gibt keine simplen Typen, alles sind Objekte mit Methoden

So sieht eine einfache Methoden-Signatur aus: def add(x: Int, y: Int): Int = x + y

Anstatt void gibt es den Datentyp Unit für Methoden ohne Rückgabewert:

  • def sayHello(): Unit = println(„Hello ! “ )

Auf Methoden kann ähnlich wie auf Properties zugegriffen werden.

In scala wird automatisch die letzte Zuweisung einer Methode zurück gegeben, ohne return

Als Methodennamen gehen nahezu alle Zeichen, inkl. +, *, … und weiteren Operatoren, die somit überladen werden können

  • object.+(123) ruft die Methode + auf Object und kann auch object + 123 geschrieben werden => Jeder Operator ist eine Methode.

Neben Klassen (Schlüsselwort class) gibt es Objekte (object), was eine statische Klasse bzw. ein Singleton ist.

Eine Klasse hat immer einen Standart-Konstruktor, welcher über die Signatur definiert ist und beliebig viele weitere überladene.
[code]
class Train(number: String) {
def this () = this („Default“)
def this (n1: String, n2: String) = this (n1 + n2)
}
[/code]
Durch hinzufügen von val oder var in der Klassensignatur werden automatisch Properties mit diesem Namen erzeugt:

  • class Train( val kind: String, val number: String)

Durch das Keywort lazy kann man die Berechnung von Properties auf den ersten Zugriff und nicht auf die Instantierung ändern:

  • lazy val asMinutes: Int = // compute the value

Es gibt packages in scala. Aber im Gegensatz zu Java, lassen sich packages verschachteln.
[code]
package org.scalatrain
package util
class Bar extends Foo // is in org.scalatrain.util
[/code]

Klassen lassen sich besser importieren als in Java

  • import org.scalatrain._ importiert alles Unterobjekte des Packages
  • import org.scalatrain.{ Time, Train } importiert nur die Objekte Time und Train aus dem Package
  • import java.sql.{ Date => SqlDate } importiert die Klasse Date; diese heisst aber im lokalen Kontext jetzt SqlDate

Es gibt in scala Sichtbarkeiten.

  • Die gleichen wie in Java
  • Standard ist public und muss nicht gesondert ausgewiesen werden
  • Es ist eine fein granularer Sichtbarkeit möglich durch Angabe des Packages in [] hinter der Sichtbarkeit: private[foo]
  • private [this] beschränkt die Sichtbarkeit auf die Instanz

Companion objects sind objects, welche den selben Namen haben wie ein Klasse und auch in der selben Datei sind.

  • Klassen haben Zugriff auf Methoden des Objekts
  • Werden z.B. für Factories benutzt. Es existiert danach automatisch die Factory-Methode: val bla = Bla() // creates new Bla()

Per require(param == 2, „This must obviously fail! „) lassen sich Parameter prüfen. Es wird ansonsten ne Exception geworfen.

case Klassen erzeugen automatisch objects und alle Paramter in der Klassensignatur werden auch ohne val bzw. var als Property angelegt. Darüber hinaus werden auch die Methoden toString und hashCode für Vergleiche automatisch erzeugt.

Per Extension spec2 lassen sich deklarative Test schreiben, die sich auch in Eclipse ausführen lassen
[code]
package org.scalatrain

import org.junit.runner.RunWith
import org.specs2.mutable.Specification
import org.specs2.runner.JUnitRunner
import java.lang.{ IllegalArgumentException => IAE }

@RunWith(classOf[JUnitRunner])
class TimeSpec extends Specification{

„Creating a Time“ should {
„throw IAE for invalid hours“ in {
Time(hours = -1) must throwAn[IAE]
Time(hours = 24) must throwAn[IAE]
}
}

„Calling Time.minus“ should {
„return the correct time difference“ in {
Time(12, 30) – Time(12, 15) must beEqualTo(15)
}
}
}
[/code]

Wenn ein Objekt gerufen wird, wird automatisch die apply Methode dieses gerufen

  • Time() == Time.apply()

Es gibt nahezu die gleichen Collection-Typen wie in Java

  • List, Set, Map, …
  •  z.B. List(1, 2, 3) oder Map(1 -> „a“, 2 -> „b“)
  • Collections gibt es veränderlich und unveränderlich. Standard ist unveränderlich. Dabei wird bei jeder Änderung eine veränderte Kopie zurück gegeben, dass orignal jedoch nie verändert.

[code]
val numbers = Vector(1, 2, 3)
numbers :+ 4
(res0: …immutable.Vector[Int] = Vector(1, 2, 3, 4))
numbers
res1: …immutable.Vector[Int] = Vector(1, 2, 3)
[/code]

  • liste +: 4 hängt ein Element am Ende an
  • 4 :+ liste fügt es am Anfang an
  • Es gibt weiter Collection-Funktionen: map, sortWith, contains, filter, …
  • flatMap entfernt eine Dimension einer Collection: z.B. List of Strings wird zu List of Chars

Funktionen sind Objekte und lassen sich als Paramter z.B. an die Methode map übergeben
[code]
val numbers = List(1, 2, 3)
numbers map (x => x + 1)
res0: List[Int] = List(2, 3, 4)
numbers map ((x: Int) => x + 1)
res1: List[Int] = List(2, 3, 4)
numbers map (_ + 1)
List[Int] = List(2, 3, 4)
[/code]

Ansonsten kann ich bis jetzt nur sagen, dass Tag 1 des Kurses echt gut war. Und natürlich auch anstrengend, weil sowohl die Syntax, als auch die Denke ne andere ist. Ach ja, der Kurs ist der von typesafe, den Erfindern von sacala.

GD Star Rating
loading...

Kommentar verfassen