Scala

1)

2)

Seminar 1908
Objektorientierte
Programmiersprachen and
Friends
Montag, 11. Februar 13

Martin Klinke
Matrikelnr. 8033978
FernUniversität Hagen
Lehrgebiet Programmiersysteme
betreut von Dr. Daniela Keller
Studiengang M. Sc. Prakt. Inf.
1

Inhalt
• Einleitung
• Programmiermodell
• Sprachelemente
• Weitere Konzepte
• Zusammenfassung und Bewertung


2

Inhalt
• Einleitung
• Sprachelemente


3

Einleitung
• Scala vereint objektorientierte und funktionale Konzepte
• Scala überzeugt durch kompakte Syntax, geringe Redundanz, hohe
Ausdrucksstärke
• Stichwort Inferenz: Typinferenz, Semikoloninferenz
• Entwickelt von Martin Odersky und seinem Team seit 2001 an der EPFL in der
Schweiz
• War Doktorand von Niklaus Wirth, dem Erﬁnder von Pascal


4

Inhalt
• Einleitung
• Sprachelemente


5

Programmiermodell
• Scala-Programme laufen in der
JVM (auch unter .NET)

3)

4)

• Quellcode in Textdateien
• Java-Konventionen empfohlen,
aber kein Muss
• Klassen in gleichnamigen
Dateien
• Paketstruktur entspricht
Verzeichnisstruktur
• zahlreiche Bibliotheken

5)

6

6)

7)

8)
9)

Programmiermodell - Tools


7

Programmiermodell - HelloWorld
object HelloWorldMain {
def main(args: Array[String]) {
println("Hello World!")
}
}

object HelloWorldAppWithArgs extends App {
println("Hello World! args: " + (args mkString " "))
}


8

Inhalt
• Einleitung
• Sprachelemente


9

Klassen
class Square(var length: Int) {
def printInfo() {
println("Square with length " + length)
}
def area() = length * length
def calc3DVolume(height: Int) : Int = {
area * height
}
}


10

Objekte
• Objekte als Instanzen von
Klassen

val s = new Square(2)
s.printInfo
println(s.length)
object Figure {
var count: Int = 0

• Objekte als Singleton-/
Companion-Objekte, vgl.
static-Deklaration in Java

def printFiguresInfo() {
println("Number of figures: "
+ count)
}
}
class Figure(name: String) {
Figure.count += 1
println("New figure: " + name)
}


11

Anweisungen
• Zwei Formen für
Methodenaufrufe
• Arithmetische Operatoren sind
als Methoden implementiert
• Präzedenz anhand des ersten
Zeichens des
Methodennamens, Tabelle

val
val
val
val

a
b
c
d

=
=
=
=

1
2
a.+(b)
a + c

val x = this.test(c, d)
val y = this test (a, b)
def test(a: Int, b: Int): Boolean =
a > b

• Ausname: Methodenname
endet mit =
(z.B. +=, <=, >= etc.)


12

Kontrollstrukturen
• imperativ (Rückgabetyp Unit)
• while

def whileLoop() {
var count = 0
while (count < 10) {
println(count)
count += 1
}
}

• do-while def doWhileLoop() {

• funktional (Rückgabetyp nutzbar)
• if-else
• for
• try-catch-ﬁnally
• match-case

var count = 0
do {
println(count)
count += 1
} while (count < 10)
}

13

Konstrollstrukturen - if-else

def divisors(n: Long, testDivisor: Long): List[Long] = {
if (testDivisor * testDivisor > n)
List(n)
else if (n % testDivisor == 0)
testDivisor :: divisors(n, testDivisor + 1)
else
divisors(n, testDivisor + 1)
}


14

Kontrollstrukturen - for

for (
i <- 1 to 50 if i % 2 == 0;
k <- divisors(i, 2) if k % 2 != 0;
l = -k
) {
println("Odd divisor of even " + i + ": " + k +
" (negative: " + l + ")")
}


15

Lambda-Ausdrücke, Funktionen höherer Ordnung

println((1 to 5).filter(x => x % 2 == 0))
//-> Vector(2, 4)


16

Immutable vs. Mutable
Immutable:
import scala.collection.immutable.Map
object ImmutableDemo {
val x = Map[Int, String]()
x += (3 -> "three") //does not compile
val i = 3
i = 4 //does not compile
}
Mutable:
import scala.collection.mutable.Map
class MutableDemo {
val x = Map[Int, String]()
x += (3 -> "three") //works!
var i = 3
i = 4 //works!
}

17

Typsystem
• Strenges Typsystem
• Typen werden durch Klassen und Traits deﬁniert
• Implizite Typumwandlung
object ImplicitDemo extends App {
implicit def string2mystring(string: String): MyString =
new MyString(string)
class MyString(string: String) {
def insertBlanks(): String = string.toList.mkString(" ")
}
println("ABCDEFG".insertBlanks)
//println(string2mystring("ABCDEFG").insertBlanks)
}

18

Typsystem

Scala-Typhierarchie

19

Parametrischer Polymorphismus
class
class
class
class
class

UpperBound[T <: AnyRef]
LowerBound[T >: String]
NonVariant[T]
Covariant[+T]
ContraVariant[-T]

object ParametricPolymorphismDemo extends App {
val upperBound = new UpperBound[String]
val lowerBound = new LowerBound[AnyRef]
val nonVar = new NonVariant[String]
val coVar: Covariant[Object] = new Covariant[String]
val contraVar: ContraVariant[String] = new ContraVariant[Object]
}


20

Dynamische Komponente
def instanceOfVersion(someObject: Any): String = {
(if (someObject.isInstanceOf[String])
someObject.asInstanceOf[String]
else
"no string") + " (instanceOf)"
}
def matchVersion(someObject: Any): String = {
(someObject match {
case s: String => s
case _: Any => "no string"
}) + " (match)"
}


21

Überladen von Methoden
• Überladen erfolgt durch Deﬁnitionen mit demselben Methodennamen
und unterschiedlichen Parameterlisten

def getAsString(value: Double, maxDigits: Int) = { ... }
def getAsString(value: Int) = { ... }


22

Überschreiben, dynamisches Binden von
Methoden
• Überschreiben erfolgt durch
Schlüsselwort override
• Dynamisches Binden erfolgt
beim Aufruf der Methode
printLevel() auf dem Alias x vom
Typ BaseClass, der auf eine
Instanz vom Typ SubClass1
zeigt
• Ausgeführt wird die in
SubClass1 deﬁnierte Methode,
welche die Methode in
BaseClass überschreibt


abstract class BaseClass {
def printLevel() {
println("Base")
}
}
class SubClass1 extends BaseClass {
override def printLevel() {
println("Sub")
}
}
object OverrideDemo extends App {
val x: BaseClass = new SubClass1
x.printLevel //-> Sub
}

23

Inhalt
• Einleitung
• Sprachelemente


24

Multi-Threading
object ActorDemo extends App {

val client = actor {
loop {
react {
case Start =>
server ! Request
case Response =>
println(
"clnt: Resp received")
exit()
}
}
}
client.start
server.start

case object Start
case object Request
case object Response
val server = actor {
loop {
react {
case Request =>
println(
"srv: Req received")
sender ! Response
exit()
}
}
}

client ! Start
}
25

Metaprogrammierung
• Angabe von Annotations durch @-Zeichen auf Klassen, Methoden, Feldern,
Parametern
• Annotation => Konstruktoraufruf, ermöglicht Angabe von Parametern aus
dem aktuellen Gültigkeitsbereich
• Beispiele: @serializable, @unchecked
• Reﬂection-API von Java muss zur Auswertung und Implementierung eigener
Annotations genutzt werden


26

Traits
• Mächtiger als Java-Interfaces
• Ermöglichen die Wiederverwendung von Funktionalität ohne
Vererbungszwang
• Mehrfachvererbung ohne die bekannten Nachteile

10)


27

Traits - Beispiel
class Logger { def log(string: String) { println(string) } }
trait InfoPrefix extends Logger {
abstract override def log(string: String) {
super.log("[Info] " + string)
}
}
object TraitDemo extends App {
val infoLogger = new Logger with InfoPrefix
infoLogger.log("This is info")
//-> [Info] This is info
}


28

Traits - Linearisierung
• Beispiel aus dem Buch von
Martin Odersky zeigt das
Prinzip zur Vermeidung der
Mehrdeutigkeit vererbter
Methoden („Diamond Problem“)
• super-Aufrufe werden
dynamisch gebunden, statt
statisch wie bei „normaler“
Vererbung
class
trait
trait
trait
class

11)

Animal
Furry extends Animal
HasLegs extends Animal
FourLegged extends HasLegs
Cat extends Animal with Furry with FourLegged
29

apply()-Methode

class Formula(f: (Int => Int)) {
def apply(x: Int) = f(x)
}
object Formula {
def apply(f: (Int => Int)) = new Formula(f)
}
val formula = Formula(x => x * x)
println(formula(2))


30

Inhalt
• Einleitung
• Sprachelemente


31

Zusammenfassung
• Typ-/Semikolon-Inferenz
• implizite Typ-Umwandlungen
• Mixins durch Traits
• funktionale Konzepte
• Lambda-Ausdrücke
• Pattern Matching


32

Bewertung
• kompakter als Java
• Lösungen sehen häuﬁg aus, als
wären sie Bestandteil des
Sprachumfangs, dabei "nur"
Bibliotheken
• saubere Programme durch
"immutable" Konzept, Parallelität
möglich
• Konsistenz des Sprachentwurfs


• leicht zu erlernen, wenn
objektorientierte und funktionale
Grundkonzepte bekannt sind
• sehr angenehme Sprache

Bewertung:

1(Tool-Unterstützung noch nicht
auf dem Niveau von Java)

33

Grafikquellen - 1
• 1) Scala-Logo: http://www.scala-lang.org/sites/default/files/
newsflash_logo.png
• 2) Titelbild: http://www.scala-lang.org/sites/default/files/slideshow/
1158741_87567140_t.jpg
• 3) Java-Logo: http://en.wikipedia.org/wiki/File:Java_logo.svg
• 4) Microsoft .NET-Logo: http://i.microsoft.com/net/images/chrome/
net_logo.jpg
• 5) Java Duke: http://duke.kenai.com/wave/Wave.png


34

Graﬁkquellen - 2
• 6) Scala-IDE for Eclipse: http://scala-ide.org/resources/images/logo.png
• 7) Netbeans-Logo: http://netbeans.org/
• 8) IntelliJIDEA-Logo: http://www.jetbrains.com/idea/
• 9) Scala-Typhierarchie: http://www.scala-lang.org/node/71?size=_original#
• 10) Diamond Inheritance: http://en.wikipedia.org/wiki/
File:Diamond_inheritance.svg
• 11) Trait Linearization: http://www.artima.com/pins1ed/images/
linearization.jpg


35

Literaturverzeichnis
[Gar12] Garcia, Miguel: Scala.Net Compiler. http://lampwww.epﬂ.ch/~magarcia/
ScalaNET/. Version: March 2012, Abruf: 25.12.2012
[IDE12] IDE and Editor plugins. http://www.scala-lang.org/node/91.
Version: April 2012, Abruf: 25.12.2012
[Mar08] Martin Odersky. http://www.scala-lang.org/node/241. Version: August
2008, Abruf: 16.12.2012
[Ode08] Odersky, Martin: Scala’s Prehistory. http://www.scala-lang.org/node/
239. Version: August 2008, Abruf: 16.12.2012
[OSV10] Odersky, Martin ; Spoon, Lex ; Venners, Bill: Programming in Scala. Second
Edition. Artima Press, 2010
[Sca12a] Frequently Asked Questions - Deployment. http://www.scala-lang.org/faq/
2. Version: 2012, Abruf: 26.12.2012
[Sca12b] Scala 2.10.0 RC5. http://www.scala-lang.org/node/25942.
Version: December 2012, Abruf: 01.01.2013


36

Vielen Dank für die Aufmerksamkeit!


37

Scala

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (8)

Ähnlich wie Scala

Ähnlich wie Scala (20)

Scala