summaryrefslogtreecommitdiffhomepage
path: root/de-de
diff options
context:
space:
mode:
authorAndre Polykanine A.K.A. Menelion Elensúlë <andre@oire.org>2017-09-10 16:54:23 +0300
committerGitHub <noreply@github.com>2017-09-10 16:54:23 +0300
commit8c7e26537e1b0718bafb37cf423b2afe21cf8da2 (patch)
tree51935d45b9dc57ae8930d8f107729731acfd5c65 /de-de
parent6e56aa136c4f409e77e63bf678a77922184301ab (diff)
parenta392fec7345bc1570207ca06ff36fd6feb3771fe (diff)
Merge pull request #2845 from exic/master
[scala/de] Scala: German translation reviewed.
Diffstat (limited to 'de-de')
-rw-r--r--de-de/scala-de.html.markdown579
1 files changed, 290 insertions, 289 deletions
diff --git a/de-de/scala-de.html.markdown b/de-de/scala-de.html.markdown
index ddadcd8e..a8344e6a 100644
--- a/de-de/scala-de.html.markdown
+++ b/de-de/scala-de.html.markdown
@@ -8,89 +8,90 @@ contributors:
- ["Dennis Keller", "github.com/denniskeller"]
translators:
- ["Christian Albrecht", "https://github.com/coastalchief"]
+ - ["Jonas Grote", "https://github.com/exic"]
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:
+Scala-Umgebung einrichten:
1. Scala binaries herunterladen- http://www.scala-lang.org/downloads
2. Unzip/untar in ein Verzeichnis
-3. das bin Unterverzeichnis der `PATH` Umgebungsvariable hinzufügen
+3. das Unterverzeichnis `bin` der `PATH`-Umgebungsvariable hinzufügen
4. Mit dem Kommando `scala` wird die REPL gestartet und zeigt als Prompt:
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.
-Als nächstes beschäftigen wir uns mit ein paar Scala Basics.
+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-Grundlagen.
*/
/////////////////////////////////////////////////
-// 1. Basics
+// 1. Grundlagen
/////////////////////////////////////////////////
-// Einzeilige Kommentare beginnen mit zwei Slashes
+// Einzeilige Kommentare beginnen mit zwei Schrägstrichen.
/*
- Mehrzeilige Kommentare, starten
- mit einem Slash-Stern und enden mit einem Stern-Slash
+ Mehrzeilige Kommentare starten mit Schrägstrich und Stern
+ und enden mit Stern und Schrägstrich.
*/
-// Einen Wert, und eine zusätzliche neue Zeile ausgeben
+// Einen Wert und eine zusätzliche neue Zeile ausgeben:
-println("Hello world!")
+println("Hallo Welt!")
println(10)
-// Einen Wert, ohne eine zusätzliche neue Zeile ausgeben
+// Einen Wert ohne eine zusätzliche neue Zeile ausgeben:
-print("Hello world")
+print("Hallo Welt")
/*
- 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
+x = 20 // Error: reassignment to val (Fehler: neue Zuweisung zu einem unveränderlichen Wert)
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, dass der
+Scala Compiler in den meisten Fällen erraten kann, von welchem 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 +99,7 @@ true == false // false
10 > 5 // true
-// Mathematische Operationen sind wie gewohnt
+// Mathematische Operationen sind wie gewohnt:
1 + 1 // 2
2 - 1 // 1
@@ -108,88 +109,87 @@ 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 8 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' // Ein Scala Char
+// 'Einzeln ge-quotete strings gibt es nicht!' <= Das erzeugt einen Fehler!
-"hello world".length
-"hello world".substring(2, 6)
-"hello world".replace("C", "3")
+// Für Strings gibt es die üblichen Java-Methoden:
+"Hallo Welt".length
+"Hallo Welt".substring(2, 6)
+"Hallo Welt".replace("C", "3")
-// Zusätzlich gibt es noch extra Scala Methoden
-// siehe: scala.collection.immutable.StringOps
-"hello world".take(5)
-"hello world".drop(5)
+// Zusätzlich gibt es noch extra Scala-Methoden
+// siehe: scala.collection.immutable.StringOps
+"Hallo Welt".take(5)
+"Hallo Welt".drop(5)
-// String interpolation: prefix "s"
+
+// String-Interpolation: prefix "s":
val n = 45
-s"We have $n apples" // => "We have 45 apples"
+s"Wir haben $n Äpfel" // => "Wir haben 45 Äpfel"
-// 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
-s"My second daughter is ${a(0) - a(2)} years old." // => "My second daughter is 5 years old."
-s"We have double the amount of ${n / 2.0} in apples." // => "We have double the amount of 22.5 in apples."
-s"Power of 2: ${math.pow(2, 2)}" // => "Power of 2: 4"
+s"Meine zweite Tochter ist ${a(0) - a(2)} Jahre alt." // => "Meine zweite Tochter ist 5 Jahre alt."
+s"Wir haben das Doppelte von ${n / 2.0} an Äpfeln." // => "Wir haben das Doppelte von 22.5 an Äpfeln."
+s"2 im Quadrat: ${math.pow(2, 2)}" // => "2 im Quadrat: 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"
+f"5 im Quadrat: ${math.pow(5, 2)}%1.0f" // "5 im Quadrat: 25"
+f"Quadratwurzel von 122: ${math.sqrt(122)}%1.4f" // "Quadratwurzel von 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 im Innern eines Strings:
-"They stood outside the \"Rose and Crown\"" // => "They stood outside the "Rose and Crown""
+"Sie standen vor der \"Rose and Crown\"" // => "Sie standen vor der "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>
+val html = """<form id="dieform">
+ <p>Drück 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 wird hier kein Schlüsselwort "return" verwendet.
+// In Scala ist der letzte Ausdruck in einer Funktion der Rückgabewert.
def sumOfSquares(x: Int, y: Int): Int = {
val x2 = x * x
@@ -198,118 +198,118 @@ 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-Inferenz, 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 ein Schlüsselwort "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
+}
/////////////////////////////////////////////////
-// 3. Flow Control
+// 3. Flusskontrolle
/////////////////////////////////////////////////
-// Wertebereiche und Schleifen
+// Wertebereiche und Schleifen:
1 to 5
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
-// und zu parellelisieren.
+// 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 parallelisieren.
-// Ein do while Schleife
+// Ein do while Schleife
do {
- println("x ist immer noch weniger wie 10")
+ println("x ist immer noch weniger als 10")
x += 1
} 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 idiomatisch um sich wiederholende
+// Aufgaben in Scala zu lösen. Rekursive Funtionen benötigen explizit einen
+// Rückgabe-Typ, der Compiler kann ihn nicht erraten.
+// Der Rückgabe-Typ in diesem Beispiel ist Unit:
def showNumbersInRange(a: Int, b: Int): Unit = {
print(a)
@@ -331,7 +331,7 @@ val text = if (x == 10) "yeah" else "nope"
/////////////////////////////////////////////////
-// 4. Daten Strukturen (Array, Map, Set, Tuples)
+// 4. Datenstrukturen (Array, Map, Set, Tupel)
/////////////////////////////////////////////////
// Array
@@ -344,11 +344,11 @@ a(21) // Exception
// Map - Speichert Key-Value-Paare
-val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo")
+val m = Map("fork" -> "Gabel", "spoon" -> "Löffel", "knife" -> "Messer")
m("fork")
m("spoon")
m("bottle") // Exception
-val safeM = m.withDefaultValue("no lo se")
+val safeM = m.withDefaultValue("unbekannt")
safeM("bottle")
// Set - Speichert Unikate, unsortiert (sortiert -> SortedSet)
@@ -359,8 +359,8 @@ s(1) //true
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.
+// Tupel - Speichert beliebige Daten und "verbindet" sie miteinander
+// Ein Tupel 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 Tupel
+// Die Funktion gibt das Ergebnis sowie 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 Tupels 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
+ einer Scala-Datei 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!"
+def bark = "Wuff, wuff!"
-// 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
+// verwenden, ohne ein Objekt instanziieren zu müssen.
+// Ein gültiges companion Objekt einer Klasse ist es aber erst dann, wenn
+// es genauso heißt und in derselben Datei wie die Klasse definiert wurde.
object Hund {
def alleSorten = List("Pitbull", "Dackel", "Retriever")
@@ -470,50 +470,51 @@ 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
+// zusätzliche 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 braucht 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,23 +528,23 @@ 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
// mit "with" verwendet werden können.
trait Bellen {
- def bellen: String = "Woof"
+ def bellen: String = "Wuff"
}
trait Hund {
def sorte: String
@@ -556,17 +557,17 @@ class Bernhardiner extends Hund with Bellen{
scala> val b = new Bernhardiner
b: Bernhardiner = Bernhardiner@7b69c6ba
scala> b.bellen
-res0: String = Woof
+res0: String = Wuff
/////////////////////////////////////////////////
-// 6. Pattern Matching
+// 6. Mustervergleich (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,19 +577,19 @@ 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 {
case 2 | 3 | 5 => "Zahl"
- case "woof" => "String"
+ case "wuff" => "String"
case true | false => "Boolean"
case 45.35 => "Double"
case _ => "Unbekannt"
}
-// und auf Objektgleichheit
+// und auf Objektgleichheit
def matchPerson(person: Person): String = person match {
case Person("George", nummer) => "George! Die Nummer ist " + number
@@ -597,31 +598,31 @@ def matchPerson(person: Person): String = person match {
}
-// Und viele mehr...
+// Und viele mehr...
val email = "(.*)@(.*)".r // regex
def matchEverything(obj: Any): String = obj match {
// Werte:
- case "Hello world" => "Got the string Hello world"
+ case "Hallo Welt" => "string Hallo Welt gefunden"
// Typen:
- case x: Double => "Got a Double: " + x
- // Conditions:
- case x: Int if x > 10000 => "Got a pretty big number!"
- // Case Classes:
- case Person(name, number) => s"Got contact info for $name!"
+ case x: Double => "Double gefunden: " + x
+ // Bedingungen:
+ case x: Int if x > 10000 => "Ziemlich große Zahl gefunden!"
+ // Case-Klassen:
+ case Person(name, number) => s"Kontaktinformationen für $name gefunden!"
// RegEx:
- case email(name, domain) => s"Got email address $name@$domain"
- // Tuples:
- case (a: Int, b: Double, c: String) => s"Got a tuple: $a, $b, $c"
+ case email(name, domain) => s"E-Mail-Adresse $name@$domain gefunden"
+ // Tupel:
+ case (a: Int, b: Double, c: String) => s"Tupel gefunden: $a, $b, $c"
// Strukturen:
- case List(1, b, c) => s"Got a list with three elements and starts with 1: 1, $b, $c"
- // Patterns kann man ineinander schachteln:
- case List(List((1, 2, "YAY"))) => "Got a list of list of tuple"
+ case List(1, b, c) => s"Liste aus drei Elementen gefunden, startend mit 1: 1, $b, $c"
+ // Pattern kann man ineinander schachteln:
+ case List(List((1, 2, "YAY"))) => "Liste von Tupeln gefunden"
}
-// 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"
@@ -630,58 +631,58 @@ val patternFunc: Person => String = {
/////////////////////////////////////////////////
-// 37. Higher-order functions
+// 7. "Higher-order"-Funktionen
/////////////////////////////////////////////////
-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, dass Methoden und Funktionen wiederum Funtionen und Methoden
+// als Aufrufparameter oder Rückgabewert verwenden. Diese Methoden heißen
+// higher-order functions.
+// Es gibt zahlreiche higher-order-Funtionen 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
+// List
-def isGleichVier(a:Int) = a == 4
+def istGleichVier(a:Int) = a == 4
val list = List(1, 2, 3, 4)
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
+// map nimmt eine Funktion und führt sie auf jedem Element aus und erzeugt
+// eine neue Liste
-val add10: Int => Int = _ + 10
+// Funktion erwartet einen Int und gibt einen Int zurück:
+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 Funktion 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 +693,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 so lange, 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,108 +717,108 @@ 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 sie verstehen, wie sie funktionieren.
+// Dieses Tutorial enthält Implicits, da sie in Scala an jeder Stelle
+// vorkommen und man auch mit einer Bibliothek, die Implicits benutzt, sonst
+// 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!"
+ s"Hallo $toWhom, $howMany Segenswünsche für Sie und Ihre Angehörigen!"
+
+// 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) // => "Hallo John, 1000 Segenswünsche für Sie und Ihre Angehörigen!"
-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.
-// 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
+// Hier also: "myImplicitInt", da ein Int gesucht wird
-sendGreetings("Jane") // => "Hello Jane, 100 blessings to you and yours!"
+sendGreetings("Jane") // => "Hallo Jane, 100 Segenswünsche für Sie und Ihre Angehörigen!"
-// 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,
+// dann wird die Methode aufgerufen:
"Retriever".sorte // => "Golden Retriever"
/////////////////////////////////////////////////
-// 19. Misc
+// 9. Sonstiges
/////////////////////////////////////////////////
// Importe
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 = {
- // Sachen kommen hierhin
+ // Zeugs hier rein.
}
}
// 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,13 +827,13 @@ writer.close()
```
-## Weiterführende Hinweise
+## Weiterführende Hinweise
-// DE
+### DE
* [Scala Tutorial](https://scalatutorial.wordpress.com)
* [Scala Tutorial](http://scalatutorial.de)
-// EN
+### EN
* [Scala for the impatient](http://horstmann.com/scala/)
* [Twitter Scala school](http://twitter.github.io/scala_school/)
* [The scala documentation](http://docs.scala-lang.org/)