Urlaub -> Scala (3)
Kategorie Scala
Heute beschäftige ich mich mit case classes.
Also Klassen die Käse sind?
Hier eine case class -> case class Derivative(manufacturer : String, model : String, count : Int)
OK, und was kann man damit machen?
Heute beschäftige ich mich mit case classes.
Also Klassen die Käse sind?
Hier eine case class -> case class Derivative(manufacturer : String, model : String, count : Int)
OK, und was kann man damit machen?
Erstes Beispiel:
case class Derivative(manufacturer : String, model : String, count : Int)
val s = Derivative("Mercedes","S-Klasse",45)
println(s)
OK und wie sieht dann der output aus, wie in Java like object bla bla ????
Nein -> Derivative(Mercedes,S-Klasse,45)
Upps, ich brauche bei case classes keine ToString-Methode mehr zu implementieren genauso keine hashCode
nd equals 
OK, jetzt hängen wir an das Script folgendes an ->
def mercedes(x : Derivative) = {
x match {
case Derivative("Mercedes","S-Klasse",_) => "Mercedes S-Klasse"
case Derivative("Mercedes",_,_) => "Only Mercedes"
case Derivative(_,_,45) => "45 units"
case _ => "not defined"
}
}
println(mercedes(Derivative("Mercedes","S-Klasse",1)))
println(mercedes(Derivative("VW","Polo",45)))
println(mercedes(Derivative("Mercedes","Vito",45)))
Und schon sind wir im Basic Pattern Matching Output ->
Mercedes S-Klasse
45 units
Only Mercedes
wenn man die Zeilen
case Derivative("Mercedes",_,_) => "Only Mercedes"
case Derivative(_,_,45) => "45 units"
tauscht sieht der Output wie folgt aus:
Mercedes S-Klasse
45 units
45 units
Jetzt noch
"Only Mercedes" durch
{ println("MB"); "Only Mercedes" }
ersetzen und dann schaue ich weiter fernsehen.
Gruß JJR
case class Derivative(manufacturer : String, model : String, count : Int)
val s = Derivative("Mercedes","S-Klasse",45)
println(s)
OK und wie sieht dann der output aus, wie in Java like object bla bla ????
Nein -> Derivative(Mercedes,S-Klasse,45)
Upps, ich brauche bei case classes keine ToString-Methode mehr zu implementieren
genauso keine hashCode
nd equals
OK, jetzt hängen wir an das Script folgendes an ->
def mercedes(x : Derivative) = {
x match {
case Derivative("Mercedes","S-Klasse",_) => "Mercedes S-Klasse"
case Derivative("Mercedes",_,_) => "Only Mercedes"
case Derivative(_,_,45) => "45 units"
case _ => "not defined"
}
}
println(mercedes(Derivative("Mercedes","S-Klasse",1)))
println(mercedes(Derivative("VW","Polo",45)))
println(mercedes(Derivative("Mercedes","Vito",45)))
Und schon sind wir im Basic Pattern Matching Output ->
Mercedes S-Klasse
45 units
Only Mercedes
wenn man die Zeilen
case Derivative("Mercedes",_,_) => "Only Mercedes"
case Derivative(_,_,45) => "45 units"
tauscht sieht der Output wie folgt aus:
Mercedes S-Klasse
45 units
45 units
Jetzt noch
"Only Mercedes" durch
{ println("MB"); "Only Mercedes" }
ersetzen und dann schaue ich weiter fernsehen.
Gruß JJR
| Permalink | 
Kommentare
interessante Sache mit diesen "case-classes". Ist also praktisch so eine Art zur Laufzeit über den Konstruktor frei parametrisierbare Klasse deren Parameter später wieder entsprechend ausgewertet werden können, richtig?
Mir fällt zwar gerade kein konkreter Anwendungsfall dafür ein, aber die Tatsache dass man die case-Parameter anscheinend zur Laufzeit wie Properties frei setzen kann und auch diverse Methoden gleich mit generiert werden ist schon nicht übel
Viele Grüße,
Sebastian
Erstellt von Sebastian Stricker um 09:07:33 PM am 07/23/2009 | - Website - |
mir fallen da schon ein paar Sachen ein... z.B. habe ich eine zweite case class definiert ->
case class Model(manufacturer : String, model : String)
Bei der mercedes Methode habe ich den Parameter auf den Typ Any gesetzt und ein weiteres case im Pattern-Matching eingefügt:
def mercedes(x : Any) = {
x match {
case Derivative("Mercedes","S-Klasse",_) => "Mercedes S-Klasse"
case Derivative("Mercedes",_,_) => { println("MB"); "Only Mercedes" }
case Derivative(_,_,45) => "45 units"
case Model(vManufacturer,vModel) => "Model -> " + vManufacturer + "/" + vModel
case _ => "not defined"
}
}
Danach konnte ich sofort -> folgendes machen ->
println(mercedes(Model("VW","Jetta")))
Das heißt bei sehr dynamischen Zuordnungsalgorithmen müßte ich mir keine Gedanken mehr um Vererbung, Interfaces und den ganzen Mist machen. Ich könnte bei einer neuen Anforderung einfach eine neue Klasse machen und die Zuordungslogik einfach über ein weiteres Pattern-Matching erweitern
Nehme auch mal an, dass ich die case class mit eigenen Methoden erweiteren kann, muß ich aber noch schauen
Gruß JJR
Erstellt von JakeJBlues um 09:26:28 PM am 07/23/2009 | - Website - |
der Inline-Constructor funktioniert zumindest, also wird der Rest auch gehen
case class Derivative(manufacturer : String, model : String, count : Int) { println("constructor") }
Gruß JJR
Erstellt von JakeJBlues um 05:11:23 PM am 07/24/2009 | - Website - |