1 / 33

Scala

Scala. Vortrag im Rahmen des Seminars „Programmiersprachen“ David Ullrich. In diesem Vortrag erwartet Sie:. Einführung Besonderheiten der Sprache Beispiel-Anwendung: QuickSort Zusammenfassung. Einführung. Der Ursprung Gründe für eine neue Sprache Zielsetzung beim Entwurf. Der Ursprung.

reya
Télécharger la présentation

Scala

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Scala Vortrag im Rahmen des Seminars „Programmiersprachen“David Ullrich

  2. In diesem Vortrag erwartet Sie: • Einführung • Besonderheiten der Sprache • Beispiel-Anwendung: QuickSort • Zusammenfassung

  3. Einführung • Der Ursprung • Gründe für eine neue Sprache • Zielsetzung beim Entwurf

  4. Der Ursprung • Prof. Martin Odersky (Pizza, GJ) • Programming Methods Laboratory - LAMP • Seit 2002 in der Entwicklung • Erste Veröffentlichung Januar 2004

  5. Gründe für eine neue Sprache(nach Odersky) • Zunehmende Verbreitung vonWeb-Services stellt einen Paradigmen-Wechsel dar • Bedarf nach Unterstützung durch Programmiersprachen entsteht

  6. Ziele beim Entwurf • Verknüpfung von funktionaler und Objekt-Orientierter Programmierung • Kein Flickwerk  Synergie • Nahtlose Zusammenarbeit mit anderen Objekt-Orientierten Sprachen • Pattern-Matching als Grundlage fürXML-Bearbeitung

  7. Besonderheiten der Sprache • Das Typsystem • Klassen und Vererbung • Funktionen • Framework-Integration • Fortgeschrittene Konzepte

  8. Das Typsystem • „Alles ist ein Objekt“ • klassische Objekte aus der OOP • Funktionen  Werte  Objekte object ObjektDemo {def main(args: Array[String]): unit = System.out.println(main.toString());}

  9. Objekthierarchie in Scala (Auswahl) scala.Any scala.AnyVal scala.AnyRef (java.lang.Object) scala.Char scala.Int scala.Object java.lang.String

  10. Benutzerdefinierte Typumwandlung • Werttypen besitzen bereits verschiedene coerce-Methoden (Byte  Short  Int) • coerce-Methoden werden implizit aufgerufen def coerce: String = { [...]}

  11. Klassen und Vererbung • Singleton-Objekte • Klasseninstanzen • Vererbung • mixin-composition • generische Klassen • type-bounds

  12. Singleton-Objekte • Schlüsselwort object • Referenzierung über den Objektnamen • main-Methode bildet Startpunkt object HelloWorld {def main(args: Array[String]): unit = System.out.println(“Hello World!“);} object HelloWorld with Application { System.out.println(“Hello World!“);}

  13. Klasseninstanzen • Schlüsselwort class zur Definition • Schlüsselwort new zur Instanziierung • keine Konstruktoren • stattdessen Parameterliste class Klassendemo(a:int) {val x = a;}

  14. Vererbung • Einfachvererbung mit Schlüsselwort extends • Schnittstellen-Definition über trait • abstract Klassen nur Oberklassen • sealed Klassen nie Oberklassen • Überladen mit override • Signatur bei Überladen änderbar

  15. Schnittstellendefinition • Schnittstellen haben keinen Zustand • Parameter deshalb nicht erlaubt • enthält Methodensignaturen • können Methoden implementieren • können andere Schnittstellen erweitern trait TraitDemo {def abstractMethod(x: any): unit;def concreteMethod(x: any): String = x.toString();}

  16. mixin-composition • Unter geeigneten Umständen kann eine Klasse auch die nur die neuen Methoden erben • Die Klasse mit den neuen Methoden heißt mixin • Funktioniert nur, wenn die Oberklasse des mixins eine Oberklasse der Oberklasse der zu erweiternden Klasse ist

  17. mixin-Beispiel class Point(xc: int) {val x = xc;overridedef toString() = “x= “ + x;}class ColoredPoint(u: int, c: String) extends Point(u) {var color = c;overridedef toString() = super.toString() + “, c= “ + c;}class Point2D(xc:int, yc: int) extends Point(xc) { val y = yc;overridedef toString() = super.toString() + “, y= “ + y; } class ColoredPoint2D(xc: int, yc: int, c: String)extends Point2D(xc, yc)with ColoredPoint(xc, c);}

  18. generische Klassen • Objekttyp wird als Parameter in eckigen Klammern übergeben • Parametername kann nun wie ein Typbezeichner verwendet werden class generischesBeispiel[a](xc: a) {val x: a = xc;} [...] (args: Array[String]) [...]

  19. type-bounds • können Typ-Parameter einschränken • lower-type-bound: Typ-Parameter T muss Oberklasse eines anderen Typs A sein T >: A • upper-type-bound: Typ-Parameter T muss eine definierte Oberklasse A haben T <: A

  20. Funktionen • Parameter • polymorphe Funktionen • Currying • anonyme Funktionen • Operatoren

  21. Parameter • Übergabe erfolgt in Parameterlisten • Typangabe nach Typbezeichner • Anzahl der Parameterlisten beliebig • Funktionen selbst als Parameter möglich „Funktionen höherer Ordnung“ def fktBsp2(f: int => String, v: int): String = { f(v);} def fktBsp(a: int, b: String): unit = { [...]}

  22. Polymorphe Funktionen • sind generische Methoden • lassen sich mit Typ-Parameter versehen • lassen sich mit type-bounds einschränken • kein Bruch zwischen Klassen und Funktionen def polyBsp[T](x: T, n: Int): List[T] = { [...]}

  23. def modN(x: Int): Boolean = { ((x % 2) == 0);} Currying • Angabe mehrerer Parameterlisten erlaubt allgemeinere Methoden • Aufruf übergibt Parameterlisten und liefert eine Referenz auf eine „konfigurierte“ Methode def modN(n: Int)(x: Int): Boolean = { ((x % n) == 0);} modN(2)

  24. Anonyme Funktionen • ermöglichen Methodendefinition ohne Bezeichner • Sinnvoll bei Aufruf an einer Stelle im Code • implizite Definition erfolgt durch Compiler • Parameter-Rumpf-Trennung durch => (x: int, y: int) => x * y

  25. b = a + 3; b = a.+(3); Operatoren • Operatoren sind ebenfalls Objekte • Genauer: eine abkürzende Schreibweise • Formaler: Methoden, die einen Parameter erwarten, in einer Infix-Notation

  26. Framework-Integration • Nahtlose Interaktion mit der JRE oder der CLR war ein Entwicklungsziel • Scala derzeit ein Wrapper für JVM und Java Compiler • java.lang.* ist bereits importiert • Compile-Ergebnis ist Bytecode

  27. Fortgeschrittene Konzepte • Local Type Inference • Pattern-Matching • Regular Expression Patterns • Case-Classes • native XML-Unterstützung • Sequence Comprehensions for (val i: int <- Iterator.region(0, 23)) { [...]} for (val i: int <- Iterator.region(0, 23); i % 2 == 0) { [...]}

  28. Beispiel-Anwendung: QuickSort • Scala-Implementierung OO und funktional • Funktionale Implementierung vertauscht nicht, sondern filtert def sort(a: List[int]): List[int] = { if (a.length < 2) { a } else { val pivot = a(a.length / 2); sort(a.filter(x => x < pivot)) ::: a.filter(x => x == pivot) ::: sort(a.filter(x => x > pivot)); } }

  29. QuickSort in Java • Java-Code im Wesentlichen durch„Schlüsselwort-Transformation“ def swap(i: int, j: int): unit = { val t = a(i); a(i) = a(j); a(j) = t; } privatestaticvoid swap(int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; }

  30. Benchmark-Ergebnisse

  31. Zusammenfassung • Einige Interessante Möglichkeiten • Mainstream-Features der nahen Zukunft • Gute Integration • Schnell genug für den täglichen Einsatz • Scala ist noch nicht fertig

  32. Abschließend ... Scala (ital. Treppe) ist vielleicht nicht DER nächste Schritt, aber ein Schritt in die richtige Richtung

  33. Vielen Dank für Ihre Aufmerksamkeit.

More Related