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