Programmierparadigmen und Sprachen

Transkript

1 Fakultät Informatik Institut für Software- und Multimediatechnik Professur Softwaretechnologie Programmierparadigmen und Sprachen Scala Paul Henke Dresden,

2 Gliederung Hello World Scala? Features Demo TU Dresden, Scala Folie 2 von 21

3 Hello World object HelloWorld { def main(args: Array[String]) { println("hello, world!") TU Dresden, Scala Folie 3 von 21

4 Scala? Scalable Language wird von Martin Odersky (EPFL, Schweiz) seit 2001 entworfen und entwickelt statisch getypte Multiparadigmensprache verknüpft Objektorientierte Programmierung mit Funktionaler läuft auf der JVM sowie in.net vollständig in die jeweilige Umgebung integriert aktuelle Version TU Dresden, Scala Folie 4 von 21

5 Features Klassen Einfach Vererbung Mixins (durch Traits) Alles wird als Objekt behandelt Type Inference XML als nativer Datentyp Schönfinkeln Partial Application First Class und Higher Order Functions Closures Structural Typing Pattern Matching Tupel Actors und Messages TU Dresden, Scala Folie 5 von 21

6 Syntax Semikolons unnötig keine Operatoren Methoden können Infix geschrieben werden Klammern können bei Methoden mit maximal einem Parameter weggelassen werden statt 1.+(2) geeignet für Domain Specific Languages (durch viele Freiheiten in der Syntax) z.b. ScalaTest Framework collection should contain element 1.0 result should be >= 0 TU Dresden, Scala Folie 6 von 21

7 Klassenhierarchie TU Dresden, Scala Folie 7 von 21

8 Klassen class Person(name:String, age:int) { def Name:String = name def Age:Int = age var city:string = "" def sayhi { println("hi") override def tostring():string = name + " (" + age + ")" var p:person = new Person("Horst", 20) println(p.name) // Horst println(p) // Horst (20) p.sayhi() p.city = "Dresden" // Hi TU Dresden, Scala Folie 8 von 21

9 Singletons Objects es gibt keinen static Modifier object Math { def PI:Double = def pow(b:long,e:long) = { def sin(a:double) = { def cos(a:double) = { /*... */ println(math.pow(2,8)) // 256 TU Dresden, Scala Folie 9 von 21

10 Type Inference auf Typangaben kann ich den meisten Fällen verzichtet werden Variablen var x = 5 var y = "Scala x = "ist toll" // x:int // y:string // type mismatch var z = x * 10 // z:int Rückgabetyp von Funktionen def add(x:float, y:float) = { x+y // add(float, Float):Float TU Dresden, Scala Folie 10 von 21

11 Traits abstrakter Typ ähnlich wie Java Interfaces bzw abstrakte Klassen Mixin Composition -> Mehrfach Vererbung trait Occupation { var occupation = "" override def tostring = super.tostring + "(" + occupation + ")" trait Status { var status = "" override def tostring = super.tostring + "(" + status + ")" TU Dresden, Scala Folie 11 von 21

12 Traits class BetterPerson(n:String, a:int) extends Person(n,a) with Occupation with Status val bp = new BetterPerson("Alice", " 25) bp.occupation = "Student"; bp.status = "Married" println(bp) // Alice (25)(Student)(Married) TU Dresden, Scala Folie 12 von 21

13 Traits trait Ord[T] { def < (that: T): Boolean def <=(that: T): Boolean = (this < that) (this == that) def > (that: T): Boolean =!(this <= that) def >=(that: T): Boolean =!(this < that) class Rational(n: Int, d: Int) extends Ord[Rational] { /* */ def <(that: Rational) = numer * denom > that.numer * that.denom var r1 = new Rational(7,5) var r2 = new Rational(13,7) println(r1 > r2) // true TU Dresden, Scala Folie 13 von 21

14 First Class Functions Funktionen sind auch Objekte haben einen Typ können Variablen zugewiesen werden val printhi:() => Unit = () => println("hi") printhi() // "hi" val return5:() => Int = () => 5 return5() // 5 val add:(int,int) => Int = (x,y) => x+y add(7,3) // 10 TU Dresden, Scala Folie 14 von 21

15 Higher Order Functions Funktionen die andere Funktionen als Parameter nehmen oder zurück geben def exists[t](list:list[t], f:t => Boolean ):Boolean = { for(item <- list) if(f(item)) return true return false val l = List(2,3,5,7,8,10) println(exists(l, n => n % 4 == 0)) println(exists(l, n => n < 0)) println(exists(plist, p => p.age > 18)) // true // false // true TU Dresden, Scala Folie 15 von 21

16 Closures Funktionen die auf Variablen zugreifen können die in ihrem Scope liegen def findpersonbyname(name:string):person = { personlist.filter(p => p.name == name) var x = 3 val printx: () => Unit = () => println(x) printx() // 3 x = 23 printx() // 23 TU Dresden, Scala Folie 16 von 21

17 Tail Recursion def factorial(n:bigint):bigint = { if(n == 1) 1 else n * factorial(n-1) println(factorial(10)) // println(factorial(5000)) // StackOverflowError def factorial2(akk:bigint,n:bigint):bigint = { if(n == 1) akk else factorial2(akk*n,n-1) println(factorial2(1,5000)) // TU Dresden, Scala Folie 17 von 21

18 Currying ist die Umwandlung einer Funktion mit mehreren Argumenten in mehrere Funktionen mit je einem Argument def factorial3(akk:bigint)(n:bigint):bigint = { if(n == 1) akk else factorial2(akk*n n,n-1) println(factorial3(1)(7)) // 5400 Partial Application def fact = factorial3(1)_ println(fact(8)) // TU Dresden, Scala Folie 18 von 21

19 Pattern Matching def factorial4(akk:int, i:int):int = { i match { case 1 => akk case n => factorial2(akk*n, n-1) println(factorial4(1,9)) // def tup(exp:any) = { exp match { case (a,b) => println("matched:" + a + "," + b) case (a) => println("matched:" + a ) println(tup(5)) // Matched:5 println(tup(("bob",25))) // Matched:Bob,25 TU Dresden, Scala Folie 19 von 21

20 Quellen Offizielle Seite Scala by Example Scala Tutorial ScalaTest Framework A Weblog by Martin Odersky p// / g/ jp gg TU Dresden, Scala Folie 20 von 21

21 Fragen Fragen? TU Dresden, Scala Folie 21 von 21