OOP - Scala

OOP in Scala
Seminar Softwareentwicklung mit Scala
Wintersemester 2010/11
Martin Pfeiffer
Friedrich Schiller Universität Jena
Prof. Dr. Wolfram Amme
Christoph Henniger
Christian Schachtzabel
22. November 2010
m.pfeiffer@uni-jena.de OOP in Scala 22. November 2010 1 / 30

¨Ubersicht
1 Klassen & Objekte
2 Klassenmember
3 Vererbung
4 Weitere Konzepte

Klassen & Objekte
Klassen
Klassendefinition
Definition mit Schlüsselwort class
Klassenname und Dateiname müssen nicht übereinstimmen
Mehrere
”
public“ Klassen pro Datei zulässig
Müssen nicht im Ordner ihres Paketes definiert werden
Verwendung
Mit new werden neue Instanzen erzeugt
Kein delete, vernichten übernimmt GC
Referenzsemantik wie in Java

Klassen & Objekte
Klassen
class Person
{
var name : String = "";
}
object ClassesExample {
def main(args: Array[String]) : Unit = {
val peter = new Person()
peter.name = "Peter"
val horst = new Person()
horst.name = "Horst"
println("Persons name is: "+peter.name)
println("Persons name is: "+horst.name)
}
}

Klassen & Objekte
Objekte
Objektdefinition
Objekte haben nur eine
”
Instanz“
Implementierung des Singleton Design Pattern
Definition mit Schlüsselwort object
Verwendung
Referenzen kann Name des object zugewiesen werden
Verhält sich wie Instanz einer Klasse

Klassen & Objekte
Objekte - Beispiel
object Person{
var name : String = "";
}
// Die Referenzen peter und horst verweisen auf das selbe object
object ObjectExample {
val peter = Person
peter.name = "Peter"
val horst = Person
horst.name = "Horst"
println("Person name is: "+peter.name)
println("Person name is: "+horst.name)
}
}

Klassenmember
Klassenmember

Klassenmember
Membervariablen
Memberdeﬁnition
var - Sind Variablen
val - Value - Sind Werte
Achtung - Alles in Scala ist per Default
”
public“
Type eines initialisierten Member optional

Klassenmember
Membervariablen - Beispiel
class Person{
val name : String = "Default name"
//Type ergibt sich aus Wertzuweisung
var alter = 42
}
object MemberExample {
val peter = new Person()
//peter.name = "peter" -> Error - value nicht aenderbar
peter.alter = 43
}
}

Klassenmember
Methoden
def methodenName (param1 : ParamType) : ReturnType =
{
//Methodenkoerper
}
Eigenschaften
Werden durch das Schlüsselwort def definiert
Name der Methode erlaubt Sonderzeichen!
Parameterliste optional
Rückgabetype optional wenn eideutig
Notwendig bei return und Rekursion
Bei einzeiligen Methodenkörper {} optional
Wert der letzten Anweisung wird automatisch zurückgegeben

Klassenmember
Methoden - Beispiel
class SInt(i : Int){
val value : Int = i
def printValue() : Unit = { println(value) }
def +(other : SInt) : SInt = new SInt(value+other.value)
def ! = {
var k = 1
for(i <- 1 to value)
k *= i
new SInt(k)
}}
object MethodeExample{
def main(args: Array[String]): Unit= {
val i1 = new SInt(5)
val i2 = new SInt(2)
(i2 + i1).printValue
(i1!).printValue
}}

Klassenmember
Hauptkonstruktoren
class Example(param1 : Paramtype)
{
val member : Paramtype = param1
}
Eigenschaften
Jede Klasse hat genau 1 Hauptkonstruktor
(Leere) Parameterliste direkt nach Klassennamen
K¨orper der Klasse ist Kontruktork¨orper

Klassenmember
Hauptkonstruktoren - Beispiel
class Person(n : String, i : Int)
{
private val name = n
private var alter = i
}
object ConstructorExample {
def main(args: Array[String]) = {
val peter = new Person("peter", 42)
val horst = new Person("horst", 37)
}
}

Klassenmember
Hauptkonstruktoren - Besonderheiten
Codereduzierung
Parameter optional mit var bzw. val
F¨ur var Parameter wird private var + Getter + Setter angelegt
F¨ur val Parameter wird private val + Getter angelegt
class Person(val name : String, var alter : Int)
object GetterSetterExample{
println(peter.name)
//peter.name = "horst" -> Error
peter.alter = 43
}
}

Klassenmember
Hilfskonstuktoren
Eigenschaften
Hilfskonstruktoren sind Methoden mit dem Namen this
() auch bei parameterlosen Konstruktor notwendig
Müssen sich in ihrer Signatur unterscheiden
Müssen als erste Anweisung einer anderen Konstuktor aufrufen
Dieser muss oberhalb des aktuellen definiert sein
Kein Rückgabewert - auch nicht Unit

Klassenmember
Hilfskonstruktoren - Beispiel
class Person(n : String, i : Int)
{
private val name = n
private var alter = i
def this(n : String) = this(n, 42)
def this() = this("unknown")
}
object ConstructorExample {
val peter = new Person("peter")
val horst = new Person("horst", 37)
val unknown = new Person
}
}

Klassenmember
Getter & Setter in Scala
//Analog zu class Person(var name : String)
class Person(n : String)
{
private var _name : String = n
def name = _name
def name_= (n : String) = _name = n
}
Uniform Access Principle
Memberzugriﬀ von Methodenaufruf nicht zu unterscheiden
Implementierung der Klasse kann ge¨andert werden

Klassenmember
POJO’s in Scala
Problem mit Java Kompatibilit¨at
Java Beans erfodern getX(), setX() & isX() Methoden
Zahlreiche Frameworks setzen auf diesen Eigenschaften auf
Annotation @scala.reﬂect.BeanProperty bringt Bean Eigenschaften
class Person(@scala.reflect.BeanProperty val name : String,
@scala.reflect.BeanProperty var alter : Int)
object POJOExample {
println(peter.getName())
}
}

Vererbung
Vererbung

Vererbung
Vererbung
Eigenschaften
Scala kennt wie Java keine Mehrfachvererbung!
Definition
Vererbung durch Schlüsselwort extends bei Klassendefinition
Es muss dabei ein Konstruktor der super Klasse aufgerufen werden
Kein Superkonstruktoraufruf für Hilfskonstruktoren möglich

Vererbung
Vererbung
Eigenschaften
Scala kennt wie Java keine Mehrfachvererbung!
Definition
Vererbung durch Schlüsselwort extends bei Klassendefinition
Es muss dabei ein Konstruktor der super Klasse aufgerufen werden
Kein Superkonstruktoraufruf für Hilfskonstruktoren möglich
class Person (var name : String, val alter : Int){
def this(name : String) = this(name, 42)
}
class Dozent(name : String, var fach : String)
extends Person(name)

Vererbung
Abstrakte Klassen
Definition
Abstrakte Klassen durch das Schlüsselwort abstract
Notwendig wenn Klasse abst. Methoden oder Variablen enthält
Instanzen können nur von nicht abstrakten Klassen erzeugt werden
Abstrakte Variablen & Methoden
Abstrakte Methoden sind Methoden ohne Körper
z. B.: def print() : Unit
Abstrakte Variablen sind var & val ohne Zuweisung
z. B.: val con : Connection

Vererbung
Abstrakte Klassen - Beispiel
abstract class Connection
class USBConnection extends Connection{
def print(s : String) : Unit = {/*..*/}
}
abstract class Printer{
val con : Connection
def print(s : String) : Unit
}
class USBPrinter extends Printer{
val con = new USBConnection
def print(s : String) : Unit = con.print(s)
}

Vererbung
Überschreiben von Membern
Definition
Scala erlaubt das Überschreiben von nicht abstrakten Membern
Dazu dient das Schlüsselwort override
So deklarierte Methoden & Variablen müssen etwas überschreiben
Test durch Compiler - Java hat nur @overrride Annotation
class Person(val name : String, var alter : Int){
override def toString() = {
"Person: - name: "+name+" alter: "+alter
}
}

Weitere Konzepte
Weitere Konzepte

Weitere Konzepte
Companion Objects
Problem
Scala kennt im Gegensatz zu Java kein
”
static“
Es gibt nur object um Einzigartigkeit zu erzeugen überschreiben
Lösung
Eine Klasse & ein Object mit demselben Namen
Müssen in derselben Datei und im selben Paket deklariert werden
Bilden zusammen eine Companion Class bzw. Companion Object
Klasse kann auf private Object-Member zugreifen

Weitere Konzepte
Companion Objects
class Person(val name : String, var alter : Int){
def printObjectCount = println(Person.counter)
}
object Person{
private var counter = 0
def getInstance(name : String, alter : Int) = {
counter += 1
new Person(name, alter)
}
}
object CompanionObjectExample {
def main(args : Array[String]) = {
val peter = Person.getInstance("peter", 42)
}
}

Weitere Konzepte
Companion Objects - Apply Methode
Vorraussetzung
Im Companion Object gibt es eine apply Methode
Diese kann ¨uber den Klassennamen benutzt werden
Oft als Factory-Methode benutzt
class Person(val name : String, var alter : Int)
object Person{
def apply(name : String, alter : Int)
= new Person(name, alter)
}
object ApplyExample{
val peter = Person("peter",42)
}
}

Weitere Konzepte
Case Classes
Vorteile
Kann f¨ur das Pattern Matching benutzt werden
Alle Konstruktorparameter automatisch als val
equals und hashCode werden automatisch erzeugt
toString mit Klassenname sowie allen Parametern
Automatische apply Methode mit allen Parametern

Weitere Konzepte
Case Classes - Beispiel
abstract class Person(name : String)
case class Dozent(name: String, fachbereich : String) extends
Person(name)
case class Student(name: String, semester : Int) extends
Person(name)
object ApplyExample{
action(Student("peter", 7))
action(Dozent("horst", "Biologie"))
}
def action(person : Person) = person match{
case Student(name: String, semester : Int) =>
println(name+" ist im Semester "+semester)
case Dozent(name: String, fachbereich : String) =>
println(name+" gehoert zum Fachbereich "+fachbereich)
}}

Fragen?

OOP - Scala

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Andere mochten auch

Andere mochten auch (6)

OOP - Scala