info/learnxinyminutes-docs
1
0
Fork 0
mirror of https://github.com/adambard/learnxinyminutes-docs.git synced 2025-08-15 11:14:24 +02:00
Code Issues Releases Wiki Activity

Remove trailing spaces.

Browse Source
This commit is contained in:
Jonas Friedemann Grote
2017-09-08 12:38:30 +02:00
parent 2a3fbe26b6
commit be9e47d810
1 changed files with 229 additions and 229 deletions
Download Patch File Download Diff File Expand all files Collapse all files

458
de-de/scala-de.html.markdown
View File

@@ -12,12 +12,12 @@ filename: learnscala-de.scala
lang: de-de lang: de-de
--- ---
Scala ist eine funktionale und objektorientierte Programmiersprache Scala ist eine funktionale und objektorientierte Programmiersprache
für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben für die Java Virtual Machine (JVM), um allgemeine Programmieraufgaben
zu erledigen. Scala hat einen akademischen Hintergrund und wurde an zu erledigen. Scala hat einen akademischen Hintergrund und wurde an
der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt. der EPFL (Lausanne / Schweiz) unter der Leitung von Martin Odersky entwickelt.
```scala ```scala
/* /*
Scala Umgebung einrichten: Scala Umgebung einrichten:
@@ -28,9 +28,9 @@ Scala Umgebung einrichten:
scala> scala>
Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter. Die REPL (Read-Eval-Print Loop) ist der interaktive Scala Interpreter.
Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt Hier kann man jeden Scala Ausdruck verwenden und das Ergebnis wird direkt
ausgegeben. ausgegeben.
Als nächstes beschäftigen wir uns mit ein paar Scala Basics. Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
*/ */
@@ -42,25 +42,25 @@ Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
// Einzeilige Kommentare beginnen mit zwei Slashes // Einzeilige Kommentare beginnen mit zwei Slashes
/* /*
Mehrzeilige Kommentare, starten Mehrzeilige Kommentare, starten
mit einem Slash-Stern und enden mit einem Stern-Slash mit einem Slash-Stern und enden mit einem Stern-Slash
*/ */
// Einen Wert, und eine zusätzliche neue Zeile ausgeben // Einen Wert, und eine zusätzliche neue Zeile ausgeben
println("Hello world!") println("Hello world!")
println(10) println(10)
// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben // Einen Wert, ohne eine zusätzliche neue Zeile ausgeben
print("Hello world") print("Hello world")
/* /*
Variablen werden entweder mit var oder val deklariert. Variablen werden entweder mit var oder val deklariert.
Deklarationen mit val sind immutable, also unveränderlich Deklarationen mit val sind immutable, also unveränderlich
Deklarationen mit var sind mutable, also veränderlich Deklarationen mit var sind mutable, also veränderlich
Immutability ist gut. Immutability ist gut.
*/ */
val x = 10 // x ist 10 val x = 10 // x ist 10
x = 20 // error: reassignment to val x = 20 // error: reassignment to val
@@ -68,29 +68,29 @@ var y = 10
y = 20 // y ist jetzt 20 y = 20 // y ist jetzt 20
/* /*
Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel Scala ist eine statisch getypte Sprache, auch wenn wir in dem o.g. Beispiel
keine Typen an x und y geschrieben haben. keine Typen an x und y geschrieben haben.
In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der In Scala ist etwas eingebaut, was sich Type Inference nennt. Das heißt das der
Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist, Scala Compiler in den meisten Fällen erraten kann, von welchen Typ eine Variable ist,
so dass der Typ nicht jedes mal angegeben werden muss. so dass der Typ nicht jedes mal angegeben werden muss.
Einen Typ gibt man bei einer Variablendeklaration wie folgt an: Einen Typ gibt man bei einer Variablendeklaration wie folgt an:
*/ */
val z: Int = 10 val z: Int = 10
val a: Double = 1.0 val a: Double = 1.0
// Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0 // Bei automatischer Umwandlung von Int auf Double wird aus 10 eine 10.0
val b: Double = 10 val b: Double = 10
// Boolean Werte // Boolean Werte
true true
false false
// Boolean Operationen // Boolean Operationen
!true // false !true // false
!false // true !false // true
@@ -98,7 +98,7 @@ true == false // false
10 > 5 // true 10 > 5 // true
// Mathematische Operationen sind wie gewohnt // Mathematische Operationen sind wie gewohnt
1 + 1 // 2 1 + 1 // 2
2 - 1 // 1 2 - 1 // 1
@@ -108,44 +108,44 @@ true == false // false
6.0 / 4 // 1.5 6.0 / 4 // 1.5
// Die Auswertung eines Ausdrucks in der REPL gibt den Typ // Die Auswertung eines Ausdrucks in der REPL gibt den Typ
// und das Ergebnis zurück. // und das Ergebnis zurück.
scala> 1 + 7 scala> 1 + 7
res29: Int = 8 res29: Int = 8
/* /*
Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt Das bedeutet, dass das Resultat der Auswertung von 1 + 7 ein Objekt
von Typ Int ist und einen Wert 0 hat. von Typ Int ist und einen Wert 0 hat.
"res29" ist ein sequentiell generierter name, um das Ergebnis des "res29" ist ein sequentiell generierter name, um das Ergebnis des
Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein... Ausdrucks zu speichern. Dieser Wert kann bei Dir anders sein...
*/ */
"Scala strings werden in doppelten Anführungszeichen eingeschlossen" "Scala strings werden in doppelten Anführungszeichen eingeschlossen"
'a' // A Scala Char 'a' // A Scala Char
// 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error // 'Einzeln ge-quotete strings gibt es nicht!' <= This causes an error
// Für Strings gibt es die üblichen Java Methoden // Für Strings gibt es die üblichen Java Methoden
"hello world".length "hello world".length
"hello world".substring(2, 6) "hello world".substring(2, 6)
"hello world".replace("C", "3") "hello world".replace("C", "3")
// Zusätzlich gibt es noch extra Scala Methoden // Zusätzlich gibt es noch extra Scala Methoden
// siehe: scala.collection.immutable.StringOps // siehe: scala.collection.immutable.StringOps
"hello world".take(5) "hello world".take(5)
"hello world".drop(5) "hello world".drop(5)
// String interpolation: prefix "s" // String interpolation: prefix "s"
val n = 45 val n = 45
s"We have $n apples" // => "We have 45 apples" s"We have $n apples" // => "We have 45 apples"
// Ausdrücke im Innern von interpolierten Strings gibt es auch // Ausdrücke im Innern von interpolierten Strings gibt es auch
val a = Array(11, 9, 6) val a = Array(11, 9, 6)
val n = 100 val n = 100
@@ -154,42 +154,42 @@ s"We have double the amount of ${n / 2.0} in apples." // => "We have double the
s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4" s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4"
// Formatierung der interpolierten Strings mit dem prefix "f" // Formatierung der interpolierten Strings mit dem prefix "f"
f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25" f"Power of 5: ${math.pow(5, 2)}%1.0f" // "Power of 5: 25"
f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454" f"Square root of 122: ${math.sqrt(122)}%1.4f" // "Square root of 122: 11.0454"
// Raw Strings, ignorieren Sonderzeichen. // Raw Strings, ignorieren Sonderzeichen.
raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r." raw"New line feed: \n. Carriage return: \r." // => "New line feed: \n. Carriage return: \r."
// Manche Zeichen müssen "escaped" werden, z.B. // Manche Zeichen müssen "escaped" werden, z.B.
// ein doppeltes Anführungszeichen in innern eines Strings. // ein doppeltes Anführungszeichen in innern eines Strings.
"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown"" "They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
// Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht // Dreifache Anführungszeichen erlauben es, dass ein String über mehrere Zeilen geht
// und Anführungszeichen enthalten kann. // und Anführungszeichen enthalten kann.
val html = """<form id="daform"> val html = """<form id="daform">
<p>Press belo', Joe</p> <p>Press belo', Joe</p>
<input type="submit"> <input type="submit">
</form>""" </form>"""
///////////////////////////////////////////////// /////////////////////////////////////////////////
// 2. Funktionen // 2. Funktionen
///////////////////////////////////////////////// /////////////////////////////////////////////////
// Funktionen werden so definiert // Funktionen werden so definiert
// //
// def functionName(args...): ReturnType = { body... } // def functionName(args...): ReturnType = { body... }
// //
// Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck // Beachte: Es gibt kein return Schlüsselwort. In Scala ist der letzte Ausdruck
// in einer Funktion der Rückgabewert. // in einer Funktion der Rückgabewert.
def sumOfSquares(x: Int, y: Int): Int = { def sumOfSquares(x: Int, y: Int): Int = {
val x2 = x * x val x2 = x * x
@@ -198,75 +198,75 @@ def sumOfSquares(x: Int, y: Int): Int = {
} }
// Die geschweiften Klammern können weggelassen werden, wenn // Die geschweiften Klammern können weggelassen werden, wenn
// die Funktion nur aus einem einzigen Ausdruck besteht: // die Funktion nur aus einem einzigen Ausdruck besteht:
def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y def sumOfSquaresShort(x: Int, y: Int): Int = x * x + y * y
// Syntax für Funktionsaufrufe: // Syntax für Funktionsaufrufe:
sumOfSquares(3, 4) // => 25 sumOfSquares(3, 4) // => 25
// In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können // In den meisten Fällen (mit Ausnahme von rekursiven Funktionen), können
// Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei // Rückgabetypen auch weggelassen werden, da dieselbe Typ Inference, wie bei
// Variablen, auch bei Funktionen greift: // Variablen, auch bei Funktionen greift:
def sq(x: Int) = x * x // Compiler errät, dass der return type Int ist def sq(x: Int) = x * x // Compiler errät, dass der return type Int ist
// Funktionen können default parameter haben: // Funktionen können default parameter haben:
def addWithDefault(x: Int, y: Int = 5) = x + y def addWithDefault(x: Int, y: Int = 5) = x + y
addWithDefault(1, 2) // => 3 addWithDefault(1, 2) // => 3
addWithDefault(1) // => 6 addWithDefault(1) // => 6
// Anonyme Funktionen sehen so aus: // Anonyme Funktionen sehen so aus:
(x: Int) => x * x (x: Int) => x * x
// Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen // Im Gegensatz zu def bei normalen Funktionen, kann bei anonymen Funktionen
// sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist. // sogar der Eingabetyp weggelassen werden, wenn der Kontext klar ist.
// Beachte den Typ "Int => Int", dies beschreibt eine Funktion, // Beachte den Typ "Int => Int", dies beschreibt eine Funktion,
// welche Int als Parameter erwartet und Int zurückgibt. // welche Int als Parameter erwartet und Int zurückgibt.
val sq: Int => Int = x => x * x val sq: Int => Int = x => x * x
// Anonyme Funktionen benutzt man ganz normal: // Anonyme Funktionen benutzt man ganz normal:
sq(10) // => 100 sq(10) // => 100
// Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird, // Wenn ein Parameter einer anonymen Funktion nur einmal verwendet wird,
// bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen, // bietet Scala einen sehr kurzen Weg diesen Parameter zu benutzen,
// indem die Parameter als Unterstrich "_" in der Parameterreihenfolge // indem die Parameter als Unterstrich "_" in der Parameterreihenfolge
// verwendet werden. Diese anonymen Funktionen werden sehr häufig // verwendet werden. Diese anonymen Funktionen werden sehr häufig
// verwendet. // verwendet.
val addOne: Int => Int = _ + 1 val addOne: Int => Int = _ + 1
val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3) val weirdSum: (Int, Int) => Int = (_ * 2 + _ * 3)
addOne(5) // => 6 addOne(5) // => 6
weirdSum(2, 4) // => 16 weirdSum(2, 4) // => 16
// Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung // Es gibt einen keyword return in Scala. Allerdings ist seine Verwendung
// nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus // nicht immer ratsam und kann fehlerbehaftet sein. "return" gibt nur aus
// dem innersten def, welches den return Ausdruck umgibt, zurück. // dem innersten def, welches den return Ausdruck umgibt, zurück.
// "return" hat keinen Effekt in anonymen Funktionen: // "return" hat keinen Effekt in anonymen Funktionen:
def foo(x: Int): Int = { def foo(x: Int): Int = {
val anonFunc: Int => Int = { z => val anonFunc: Int => Int = { z =>
if (z > 5) if (z > 5)
return z // Zeile macht z zum return Wert von foo return z // Zeile macht z zum return Wert von foo
else else
z + 2 // Zeile ist der return Wert von anonFunc z + 2 // Zeile ist der return Wert von anonFunc
} }
anonFunc(x) // Zeile ist der return Wert von foo anonFunc(x) // Zeile ist der return Wert von foo
} }
///////////////////////////////////////////////// /////////////////////////////////////////////////
@@ -280,25 +280,25 @@ val r = 1 to 5
r.foreach(println) r.foreach(println)
r foreach println r foreach println
(5 to 1 by -1) foreach (println) (5 to 1 by -1) foreach (println)
// Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende
// sind optional, beim Aufruf von Methoden können die Punkte
// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden
// while Schleife // Scala ist syntaktisch sehr großzügig, Semikolons am Zeilenende
// sind optional, beim Aufruf von Methoden können die Punkte
// und Klammern entfallen und Operatoren sind im Grunde austauschbare Methoden
// while Schleife
var i = 0 var i = 0
while (i < 10) { println("i " + i); i += 1 } while (i < 10) { println("i " + i); i += 1 }
i // i ausgeben, res3: Int = 10 i // i ausgeben, res3: Int = 10
// Beachte: while ist eine Schleife im klassischen Sinne - // Beachte: while ist eine Schleife im klassischen Sinne -
// Sie läuft sequentiell ab und verändert die loop-Variable. // Sie läuft sequentiell ab und verändert die loop-Variable.
// While in Scala läuft schneller ab als in Java und die o.g. // While in Scala läuft schneller ab als in Java und die o.g.
// Kombinatoren und Zusammenlegungen sind einfacher zu verstehen // Kombinatoren und Zusammenlegungen sind einfacher zu verstehen
// und zu parellelisieren. // und zu parellelisieren.
// Ein do while Schleife // Ein do while Schleife
do { do {
println("x ist immer noch weniger wie 10") println("x ist immer noch weniger wie 10")
@@ -306,10 +306,10 @@ do {
} while (x < 10) } while (x < 10)
// Endrekursionen sind ideomatisch um sich wiederholende // Endrekursionen sind ideomatisch um sich wiederholende
// Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen // Dinge in Scala zu lösen. Rekursive Funtionen benötigen explizit einen
// return Typ, der Compiler kann ihn nicht erraten. // return Typ, der Compiler kann ihn nicht erraten.
// Unit, in diesem Beispiel. // Unit, in diesem Beispiel.
def showNumbersInRange(a: Int, b: Int): Unit = { def showNumbersInRange(a: Int, b: Int): Unit = {
print(a) print(a)
@@ -360,7 +360,7 @@ val s = Set(1,1,3,3,7)
s: scala.collection.immutable.Set[Int] = Set(1, 3, 7) s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
// Tuple - Speichert beliebige Daten und "verbindet" sie miteinander // Tuple - Speichert beliebige Daten und "verbindet" sie miteinander
// Ein Tuple ist keine Collection. // Ein Tuple ist keine Collection.
(1, 2) (1, 2)
(4, 3, 2) (4, 3, 2)
@@ -368,15 +368,15 @@ s: scala.collection.immutable.Set[Int] = Set(1, 3, 7)
(a, 2, "three") (a, 2, "three")
// Hier ist der Rückgabewert der Funktion ein Tuple // Hier ist der Rückgabewert der Funktion ein Tuple
// Die Funktion gibt das Ergebnis, so wie den Rest zurück. // Die Funktion gibt das Ergebnis, so wie den Rest zurück.
val divideInts = (x: Int, y: Int) => (x / y, x % y) val divideInts = (x: Int, y: Int) => (x / y, x % y)
divideInts(10, 3) divideInts(10, 3)
// Um die Elemente eines Tuples anzusprechen, benutzt man diese // Um die Elemente eines Tuples anzusprechen, benutzt man diese
// Notation: _._n wobei n der index des Elements ist (Index startet bei 1) // Notation: _._n wobei n der index des Elements ist (Index startet bei 1)
val d = divideInts(10, 3) val d = divideInts(10, 3)
d._1 d._1
@@ -388,32 +388,32 @@ d._2
///////////////////////////////////////////////// /////////////////////////////////////////////////
/* /*
Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar Bislang waren alle gezeigten Sprachelemente einfache Ausdrücke, welche zwar
zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in zum Ausprobieren und Lernen in der REPL gut geeignet sind, jedoch in
einem Scala file selten alleine zu finden sind. einem Scala file selten alleine zu finden sind.
Die einzigen Top-Level Konstrukte in Scala sind nämlich: Die einzigen Top-Level Konstrukte in Scala sind nämlich:
- Klassen (classes) - Klassen (classes)
- Objekte (objects) - Objekte (objects)
- case classes - case classes
- traits - traits
Diesen Sprachelemente wenden wir uns jetzt zu. Diesen Sprachelemente wenden wir uns jetzt zu.
*/ */
// Klassen // Klassen
// Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen // Zum Erstellen von Objekten benötigt man eine Klasse, wie in vielen
// anderen Sprachen auch. // anderen Sprachen auch.
// erzeugt Klasse mit default Konstruktor // erzeugt Klasse mit default Konstruktor
class Hund class Hund
scala> val t = new Hund scala> val t = new Hund
t: Hund = Hund@7103745 t: Hund = Hund@7103745
// Der Konstruktor wird direkt hinter dem Klassennamen deklariert. // Der Konstruktor wird direkt hinter dem Klassennamen deklariert.
class Hund(sorte: String) class Hund(sorte: String)
scala> val t = new Hund("Dackel") scala> val t = new Hund("Dackel")
@@ -421,8 +421,8 @@ t: Hund = Hund@14be750c
scala> t.sorte //error: value sorte is not a member of Hund scala> t.sorte //error: value sorte is not a member of Hund
// Per val wird aus dem Attribut ein unveränderliches Feld der Klasse // Per val wird aus dem Attribut ein unveränderliches Feld der Klasse
// Per var wird aus dem Attribut ein veränderliches Feld der Klasse // Per var wird aus dem Attribut ein veränderliches Feld der Klasse
class Hund(val sorte: String) class Hund(val sorte: String)
scala> val t = new Hund("Dackel") scala> val t = new Hund("Dackel")
@@ -431,14 +431,14 @@ scala> t.sorte
res18: String = Dackel res18: String = Dackel
// Methoden werden mit def geschrieben // Methoden werden mit def geschrieben
def bark = "Woof, woof!" def bark = "Woof, woof!"
// Felder und Methoden können public, protected und private sein // Felder und Methoden können public, protected und private sein
// default ist public // default ist public
// private ist nur innerhalb des deklarierten Bereichs sichtbar // private ist nur innerhalb des deklarierten Bereichs sichtbar
class Hund { class Hund {
private def x = ... private def x = ...
@@ -446,8 +446,8 @@ class Hund {
} }
// protected ist nur innerhalb des deklarierten und aller // protected ist nur innerhalb des deklarierten und aller
// erbenden Bereiche sichtbar // erbenden Bereiche sichtbar
class Hund { class Hund {
protected def x = ... protected def x = ...
@@ -457,12 +457,12 @@ class Dackel extends Hund {
} }
// Object // Object
// Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog. // Wird ein Objekt ohne das Schlüsselwort "new" instanziert, wird das sog.
// "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so // "companion object" aufgerufen. Mit dem "object" Schlüsselwort wird so
// ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse // ein Objekt (Typ UND Singleton) erstellt. Damit kann man dann eine Klasse
// benutzen ohne ein Objekt instanziieren zu müssen. // benutzen ohne ein Objekt instanziieren zu müssen.
// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn // Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn
// es genauso heisst und in derselben Datei wie die Klasse definiert wurde. // es genauso heisst und in derselben Datei wie die Klasse definiert wurde.
object Hund { object Hund {
def alleSorten = List("Pitbull", "Dackel", "Retriever") def alleSorten = List("Pitbull", "Dackel", "Retriever")
@@ -470,50 +470,50 @@ object Hund {
} }
// Case classes // Case classes
// Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra // Fallklassen bzw. Case classes sind Klassen die normale Klassen um extra
// Funktionalität erweitern. Mit Case Klassen bekommt man ein paar // Funktionalität erweitern. Mit Case Klassen bekommt man ein paar
// Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B. // Dinge einfach dazu, ohne sich darum kümmern zu müssen. Z.B.
// ein companion object mit den entsprechenden Methoden, // ein companion object mit den entsprechenden Methoden,
// Hilfsmethoden wie toString(), equals() und hashCode() und auch noch // Hilfsmethoden wie toString(), equals() und hashCode() und auch noch
// Getter für unsere Attribute (das Angeben von val entfällt dadurch) // Getter für unsere Attribute (das Angeben von val entfällt dadurch)
class Person(val name: String) class Person(val name: String)
class Hund(val sorte: String, val farbe: String, val halter: Person) class Hund(val sorte: String, val farbe: String, val halter: Person)
// Es genügt das Schlüsselwort case vor die Klasse zu schreiben. // Es genügt das Schlüsselwort case vor die Klasse zu schreiben.
case class Person(name: String) case class Person(name: String)
case class Hund(sorte: String, farbe: String, halter: Person) case class Hund(sorte: String, farbe: String, halter: Person)
// Für neue Instanzen brauch man kein "new" // Für neue Instanzen brauch man kein "new"
val dackel = Hund("dackel", "grau", Person("peter")) val dackel = Hund("dackel", "grau", Person("peter"))
val dogge = Hund("dogge", "grau", Person("peter")) val dogge = Hund("dogge", "grau", Person("peter"))
// getter
// getter
dackel.halter // => Person = Person(peter) dackel.halter // => Person = Person(peter)
// equals // equals
dogge == dackel // => false dogge == dackel // => false
// copy // copy
// otherGeorge == Person("george", "9876") // otherGeorge == Person("george", "9876")
val otherGeorge = george.copy(phoneNumber = "9876") val otherGeorge = george.copy(phoneNumber = "9876")
// Traits // Traits
// Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp // Ähnlich wie Java interfaces, definiert man mit traits einen Objekttyp
// und Methodensignaturen. Scala erlaubt allerdings das teilweise // und Methodensignaturen. Scala erlaubt allerdings das teilweise
// implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt. // implementieren dieser Methoden. Konstruktorparameter sind nicht erlaubt.
// Traits können von anderen Traits oder Klassen erben, aber nur von // Traits können von anderen Traits oder Klassen erben, aber nur von
// parameterlosen. // parameterlosen.
trait Hund { trait Hund {
def sorte: String def sorte: String
@@ -527,16 +527,16 @@ class Bernhardiner extends Hund{
def beissen = false def beissen = false
} }
scala> b
res0: Bernhardiner = Bernhardiner@3e57cd70 scala> b
scala> b.sorte res0: Bernhardiner = Bernhardiner@3e57cd70
res1: String = Bernhardiner scala> b.sorte
scala> b.bellen res1: String = Bernhardiner
res2: Boolean = true scala> b.bellen
scala> b.beissen res2: Boolean = true
res3: Boolean = false scala> b.beissen
res3: Boolean = false
// Ein Trait kann auch als Mixin eingebunden werden. Die Klasse erbt vom // Ein Trait kann auch als Mixin eingebunden werden. Die Klasse erbt vom
// ersten Trait mit dem Schlüsselwort "extends", während weitere Traits // ersten Trait mit dem Schlüsselwort "extends", während weitere Traits
@@ -562,11 +562,11 @@ res0: String = Woof
// 6. Pattern Matching // 6. Pattern Matching
///////////////////////////////////////////////// /////////////////////////////////////////////////
// Pattern matching in Scala ist ein sehr nützliches und wesentlich // Pattern matching in Scala ist ein sehr nützliches und wesentlich
// mächtigeres Feature als Vergleichsfunktionen in Java. In Scala // mächtigeres Feature als Vergleichsfunktionen in Java. In Scala
// benötigt ein case Statement kein "break", ein fall-through gibt es nicht. // benötigt ein case Statement kein "break", ein fall-through gibt es nicht.
// Mehrere Überprüfungen können mit einem Statement gemacht werden. // Mehrere Überprüfungen können mit einem Statement gemacht werden.
// Pattern matching wird mit dem Schlüsselwort "match" gemacht. // Pattern matching wird mit dem Schlüsselwort "match" gemacht.
val x = ... val x = ...
x match { x match {
@@ -576,7 +576,7 @@ x match {
} }
// Pattern Matching kann auf beliebige Typen prüfen // Pattern Matching kann auf beliebige Typen prüfen
val any: Any = ... val any: Any = ...
val gleicht = any match { val gleicht = any match {
@@ -588,7 +588,7 @@ val gleicht = any match {
} }
// und auf Objektgleichheit // und auf Objektgleichheit
def matchPerson(person: Person): String = person match { def matchPerson(person: Person): String = person match {
case Person("George", nummer) => "George! Die Nummer ist " + number case Person("George", nummer) => "George! Die Nummer ist " + number
@@ -597,7 +597,7 @@ def matchPerson(person: Person): String = person match {
} }
// Und viele mehr... // Und viele mehr...
val email = "(.*)@(.*)".r // regex val email = "(.*)@(.*)".r // regex
def matchEverything(obj: Any): String = obj match { def matchEverything(obj: Any): String = obj match {
@@ -620,8 +620,8 @@ def matchEverything(obj: Any): String = obj match {
} }
// Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden // Jedes Objekt mit einer "unapply" Methode kann per Pattern geprüft werden
// Ganze Funktionen können Patterns sein // Ganze Funktionen können Patterns sein
val patternFunc: Person => String = { val patternFunc: Person => String = {
case Person("George", number) => s"George's number: $number" case Person("George", number) => s"George's number: $number"
@@ -633,13 +633,13 @@ val patternFunc: Person => String = {
// 37. Higher-order functions // 37. Higher-order functions
///////////////////////////////////////////////// /////////////////////////////////////////////////
Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden Scala erlaubt, das Methoden und Funktion wiederum Funtionen und Methoden
als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen als Aufrufparameter oder Return Wert verwenden. Diese Methoden heissen
higher-order functions higher-order functions
Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für Es gibt zahlreiche higher-order functions nicht nur für Listen, auch für
die meisten anderen Collection Typen, sowie andere Klassen in Scala die meisten anderen Collection Typen, sowie andere Klassen in Scala
Nennenswerte sind: Nennenswerte sind:
"filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall" "filter", "map", "reduce", "foldLeft"/"foldRight", "exists", "forall"
## List ## List
@@ -649,39 +649,39 @@ val resultExists4 = list.exists(isEqualToFour)
## map ## map
// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt // map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt
// eine neue Liste // eine neue Liste
// Funktion erwartet ein Int und returned ein Int
val add10: Int => Int = _ + 10 // Funktion erwartet ein Int und returned ein Int
val add10: Int => Int = _ + 10
// add10 wird auf jedes Element angewendet // add10 wird auf jedes Element angewendet
List(1, 2, 3) map add10 // => List(11, 12, 13) List(1, 2, 3) map add10 // => List(11, 12, 13)
// Anonyme Funktionen können anstatt definierter Funktionen verwendet werden // Anonyme Funktionen können anstatt definierter Funktionen verwendet werden
List(1, 2, 3) map (x => x + 10) List(1, 2, 3) map (x => x + 10)
// Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion // Der Unterstrich wird anstelle eines Parameters einer anonymen Funktion
// verwendet. Er wird an die Variable gebunden. // verwendet. Er wird an die Variable gebunden.
List(1, 2, 3) map (_ + 10) List(1, 2, 3) map (_ + 10)
// Wenn der anonyme Block und die Funtion beide EIN Argument erwarten, // Wenn der anonyme Block und die Funtion beide EIN Argument erwarten,
// kann sogar der Unterstrich weggelassen werden. // kann sogar der Unterstrich weggelassen werden.
List("Dom", "Bob", "Natalia") foreach println List("Dom", "Bob", "Natalia") foreach println
// filter // filter
// filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet // filter nimmt ein Prädikat (eine Funktion von A -> Boolean) und findet
// alle Elemente die auf das Prädikat passen // alle Elemente die auf das Prädikat passen
List(1, 2, 3) filter (_ > 2) // => List(3) List(1, 2, 3) filter (_ > 2) // => List(3)
case class Person(name: String, age: Int) case class Person(name: String, age: Int)
@@ -692,19 +692,19 @@ List(
// reduce // reduce
// reduce nimmt zwei Elemente und kombiniert sie zu einem Element, // reduce nimmt zwei Elemente und kombiniert sie zu einem Element,
// und zwar solange bis nur noch ein Element da ist. // und zwar solange bis nur noch ein Element da ist.
// foreach // foreach
// foreach gibt es für einige Collections // foreach gibt es für einige Collections
val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100) val aListOfNumbers = List(1, 2, 3, 4, 10, 20, 100)
aListOfNumbers foreach (x => println(x)) aListOfNumbers foreach (x => println(x))
aListOfNumbers foreach println aListOfNumbers foreach println
// For comprehensions // For comprehensions
// Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets. // Eine for-comprehension definiert eine Beziehung zwischen zwei Datensets.
// Dies ist keine for-Schleife. // Dies ist keine for-Schleife.
for { n <- s } yield sq(n) for { n <- s } yield sq(n)
val nSquared2 = for { n <- s } yield sq(n) val nSquared2 = for { n <- s } yield sq(n)
@@ -716,58 +716,58 @@ for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared
// 8. Implicits // 8. Implicits
///////////////////////////////////////////////// /////////////////////////////////////////////////
// **ACHTUNG:** // **ACHTUNG:**
// Implicits sind ein sehr mächtiges Sprachfeature von Scala. // Implicits sind ein sehr mächtiges Sprachfeature von Scala.
// Es sehr einfach // Es sehr einfach
// sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am // sie falsch zu benutzen und Anfänger sollten sie mit Vorsicht oder am
// besten erst dann benutzen, wenn man versteht wie sie funktionieren. // besten erst dann benutzen, wenn man versteht wie sie funktionieren.
// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle // Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle
// vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles // vorkommen und man auch mit einer Lib die Implicits benutzt nichts sinnvolles
// machen kann. // machen kann.
// Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren. // Hier soll ein Grundverständnis geschaffen werden, wie sie funktionieren.
// Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte // Mit dem Schlüsselwort implicit können Methoden, Werte, Funktion, Objekte
// zu "implicit Methods" werden. // zu "implicit Methods" werden.
implicit val myImplicitInt = 100 implicit val myImplicitInt = 100
implicit def myImplicitFunction(sorte: String) = new Hund("Golden " + sorte) implicit def myImplicitFunction(sorte: String) = new Hund("Golden " + sorte)
// implicit ändert nicht das Verhalten eines Wertes oder einer Funktion // implicit ändert nicht das Verhalten eines Wertes oder einer Funktion
myImplicitInt + 2 // => 102 myImplicitInt + 2 // => 102
myImplicitFunction("Pitbull").sorte // => "Golden Pitbull" myImplicitFunction("Pitbull").sorte // => "Golden Pitbull"
// Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein // Der Unterschied ist, dass diese Werte ausgewählt werden können, wenn ein
// anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von // anderer Codeteil einen implicit Wert benötigt, zum Beispiel innerhalb von
// implicit Funktionsparametern // implicit Funktionsparametern
// Diese Funktion hat zwei Parameter: einen normalen und einen implicit // Diese Funktion hat zwei Parameter: einen normalen und einen implicit
def sendGreetings(toWhom: String)(implicit howMany: Int) = def sendGreetings(toWhom: String)(implicit howMany: Int) =
s"Hello $toWhom, $howMany blessings to you and yours!" s"Hello $toWhom, $howMany blessings to you and yours!"
// Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet // Werden beide Parameter gefüllt, verhält sich die Funktion wie erwartet
sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!" sendGreetings("John")(1000) // => "Hello John, 1000 blessings to you and yours!"
// Wird der implicit Parameter jedoch weggelassen, wird ein anderer // Wird der implicit Parameter jedoch weggelassen, wird ein anderer
// implicit Wert vom gleichen Typ genommen. Der Compiler sucht im // implicit Wert vom gleichen Typ genommen. Der Compiler sucht im
// lexikalischen Scope und im companion object nach einem implicit Wert, // lexikalischen Scope und im companion object nach einem implicit Wert,
// der vom Typ passt, oder nach einer implicit Methode mit der er in den // der vom Typ passt, oder nach einer implicit Methode mit der er in den
// geforderten Typ konvertieren kann. // geforderten Typ konvertieren kann.
// Hier also: "myImplicitInt", da ein Int gesucht wird // Hier also: "myImplicitInt", da ein Int gesucht wird
sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!" sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!"
// bzw. "myImplicitFunction" // bzw. "myImplicitFunction"
// Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und // Der String wird erst mit Hilfe der Funktion in Hund konvertiert, und
// dann wird die Methode aufgerufen // dann wird die Methode aufgerufen
"Retriever".sorte // => "Golden Retriever" "Retriever".sorte // => "Golden Retriever"
@@ -780,27 +780,27 @@ sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!"
import scala.collection.immutable.List import scala.collection.immutable.List
// Importiere alle Unterpackages // Importiere alle Unterpackages
import scala.collection.immutable._ import scala.collection.immutable._
// Importiere verschiedene Klassen mit einem Statement // Importiere verschiedene Klassen mit einem Statement
import scala.collection.immutable.{List, Map} import scala.collection.immutable.{List, Map}
// Einen Import kann man mit '=>' umbenennen // Einen Import kann man mit '=>' umbenennen
import scala.collection.immutable.{List => ImmutableList} import scala.collection.immutable.{List => ImmutableList}
// Importiere alle Klasses, mit Ausnahem von.... // Importiere alle Klasses, mit Ausnahem von....
// Hier ohne: Map and Set: // Hier ohne: Map and Set:
import scala.collection.immutable.{Map => _, Set => _, _} import scala.collection.immutable.{Map => _, Set => _, _}
// Main // Main
object Application { object Application {
def main(args: Array[String]): Unit = { def main(args: Array[String]): Unit = {
@@ -810,14 +810,14 @@ object Application {
// I/O // I/O
// Eine Datei Zeile für Zeile lesen // Eine Datei Zeile für Zeile lesen
import scala.io.Source import scala.io.Source
for(line <- Source.fromFile("myfile.txt").getLines()) for(line <- Source.fromFile("myfile.txt").getLines())
println(line) println(line)
// Eine Datei schreiben // Eine Datei schreiben
val writer = new PrintWriter("myfile.txt") val writer = new PrintWriter("myfile.txt")
writer.write("Schreibe Zeile" + util.Properties.lineSeparator) writer.write("Schreibe Zeile" + util.Properties.lineSeparator)
@@ -826,7 +826,7 @@ writer.close()
``` ```
## Weiterführende Hinweise ## Weiterführende Hinweise
// DE // DE
* [Scala Tutorial](https://scalatutorial.wordpress.com) * [Scala Tutorial](https://scalatutorial.wordpress.com)