"Untergrenze" in Scala Verständnis

Question

Ich versuche zu verstehen "untere Grenze" in Scala. Hier finden Sie das folgende Beispiel

class Animal 
class Dog extends Animal 
class Puppy extends Dog 
class Human extends Animal 
class Plant 
class AnimalDisplay{ 
    def displayUptoDog [T >: Dog](t: T){ 
    println(t) 
    } 

    def displayUptoAnimal [T >: Animal](t: T){ 
    println(">>"+t.getClass()) 
    } 

} 

object ScalaLowerBoundsTest { 
    def main(args: Array[String]) {  
    val animal = new Animal 
    val dog = new Dog 
    val puppy = new Puppy 
    val human=new Human 
    val plant = new Plant 
    val animalDisplay = new AnimalDisplay 

    println("Upto Animal") 
    animalDisplay.displayUptoAnimal(animal) 
    animalDisplay.displayUptoAnimal(dog) 
    animalDisplay.displayUptoAnimal(puppy) 
    animalDisplay.displayUptoAnimal(human) 
    animalDisplay.displayUptoAnimal(plant) 

println("Upto Dog") 
    animalDisplay.displayUptoDog(animal)  
    animalDisplay.displayUptoDog(dog) 
    animalDisplay.displayUptoDog(puppy) 
// prints: com.typeSystem.typeBound.lowerBound.Puppy@1b6d3586 
    animalDisplay.displayUptoDog(human) 
//print:com.typeSystem.typeBound.lowerBound.Human@4554617c 
    animalDisplay.displayUptoDog(plant) 
//prints:com.typeSystem.typeBound.lowerBound.Plant@74a14482 
    } 
} 

Meine Fragen

1. sind als Welpe nicht ein Hund ist und nicht eine Superklasse von Hund, dann warum animalDisplay.displayUptoDog(puppy) erlaubt? einige echte usecase wird mir helfen, besser zu verstehen,

2. Wenn es (animalDisplay.displayUptoDog(puppy)) erlaubt es dann sollte Druck com.typeSystem.typeBound.lowerBound.Dog@xxxxx statt com.typeSystem.typeBound.lowerBound.Puppy@1b6d3586

3. animalDisplay.displayUptoDog (human), wo Mensch nicht eine Superklasse ist von Hund warum ist es dann erlaubt und Druck „com.typeSystem.typeBound.lowerBound.Human@4554617c“
4. animalDisplay.displayUptoDog (Pflanze), wo Pflanze nicht in der gleichen Hierarchie ist, t hen, warum es auch und „com.typeSystem.typeBound.lowerBound.Plant@74a14482“
Druck erlaubt ist

Lassen Sie mich wissen, ob ich irgendeine Sache ist

Answer 1

animalDisplay.displayUptoDog(puppy) erlaubt bin fehlt, weil Sie Puppy werfen können zu einem Dog, wie folgt aus:

animalDisplay.displayUptoDog(puppy: Dog) 

Jetzt können Sie fragen, was ist der Punkt, der untere Schranken für T in Methodensignaturen verwenden, einfach, wenn Sie es, das Objekt zu T upCast kann so f es ist? Um diese Frage zu beantworten, denke ich, dass es am besten ist, ein Beispiel zu betrachten, wo untere Grenzen tatsächlich nützlich oder sogar notwendig sind.

Ein sehr häufiger Anwendungsfall für die untere Grenze ist, wenn Sie, dass einige Verfahren einen Wert des Typs, um sicherzustellen, möchten zurückzugibt, die mit einem anderen Typ, zum Beispiel in Option[A] gemeinsam ist, ist es eine Methode:

def getOrElse[B >: A](default: ⇒ B): B 

Wenn wir möchten, dass es der Typ ist, der für A und B üblich ist, ist die einzige sinnvolle Option, wenn A ein Subtyp von B ist. Im umgekehrten Fall (B <: A) konnten Sie A nicht zurückgeben, wenn diese Option Some[A] war, da A kein Untertyp von B ist. Hier

ist ein Beispiel, wie es funktioniert, wenn wir es auf die Dog Klassenhierarchie gelten:

val d1 = Some(dog).getOrElse(puppy) 
d1: Dog = $sess.cmd1$Dog@55e02661 

val d2 = (None: Option[Dog]).getOrElse(puppy) 
d2: Dog = $sess.cmd2$Puppy@420068a 

val d3 = Some(puppy).getOrElse(dog) 
d3: Dog = $sess.cmd2$Puppy@420068a 

val d4 = (None: Option[Puppy]).getOrElse(dog) 
d4: Dog = $sess.cmd1$Dog@55e02661 

Wie Sie in allen Fällen sehen sie wie erwartet verhält. Rufen getOrElse, wenn A und B sind entweder Dog oder Puppy gibt immer einen Typ, der für beide von ihnen ist, die Dog ist.