理解 Scala 对抽象类型和类的使用

Question

下一个代码无法编译。为什么Santorin不能吃HorseFood？ Tornado 被声明为新的Horse，而Horse 是Animal 的子类型，但它可以“吃掉”HorseFood。

import scala.io.StdIn._
import util._


class Food

abstract class Animal
{
    type SuitableFood <: Food
    def eat(food: SuitableFood)
}

class Grass extends Food  /*extends meaning should be "more specific than*/
class Fish extends Food
class HorseFood extends Grass

class Cow extends Animal
{
    type SuitableFood = Grass
    override def eat(food: SuitableFood) = {}
}

class Horse extends Animal
{
  type SuitableFood = Grass
  override def eat(food: SuitableFood) = {}
}

class Whale extends Animal
{
    type SuitableFood = Fish
    override def eat(food: SuitableFood) = {}

}

object abstractExample1 {

  def main(args: Array[String]) {

    val bessy: Animal = new Cow
    println("bessy = " + bessy)
    bessy eat (new Grass).asInstanceOf[bessy.SuitableFood]
     /*added this line because of a great answer someone posted for this questions but he deleted*/

    val willie: Animal = new Whale
    println("willie = " + willie)

    val santorin: Animal = new Horse
    println("santorin = " + santorin)

    val tornado = new Horse
    tornado eat new HorseFood

    print("tornado = " + tornado)
    santorin.eat(new HorseFood)

  }

}

这不应该被自动允许吗（如Horse 扩展Animal）？为什么不呢？

注意Tornado，声明可以吃HorseFood，扩展Grass，并且Horse类的食物参数是Grass。

= 有问题吗？我的意思是，SuitableFood 正是 Grass 而不是 Grass 的类 C 扩展。

Answer 1

Santorin 是 Animal 而不是 Horse，所以它“吃”“类型”而不是 HorseFood。这是因为对它的引用是针对Animal。 更改val santorin: Animal = new Horse 到val santorin: Horse = new Horse 它会正常工作

Answer 2

你应该阅读variance。

你的类是不变的。这意味着Animal 和SuitableFood <: Food 不能是Animal 和SuitableFood = HorseFood。

如果你将你的类重写为类泛型风格，你可以看到它：

trait Food
class Grass extends Food
class HorseFood extends Grass

abstract class Animal[SuitableFood <: Food] {
    def eat(food: SuitableFood)
}

val animal1: Animal[HorseFood] = null
//the next line doesn't compile because Animal[HorseFood] isn't a subclass of Animal[Food]
val animal2: Animal[Food] = animal1

所以可以吃Food的动物不能吃HorseFood。

Answer 3

Animal#SuitableFood 是Food 的子类型

implicitly[Animal#SuitableFood <:< Food]

分配给Animal-typed val 的Horse 的每个实例都包含全新的SuitableFood 类型，它是Animal#SuitableFood 的子类型

val santorin: Animal = new Horse
val santorin2: Animal = new Horse

implicitly[santorin.SuitableFood <:< Animal#SuitableFood]
implicitly[santorin2.SuitableFood <:< Animal#SuitableFood]
implicitly[santorin.SuitableFood =:= santorin2.SuitableFood] //-- fails
//                     ^^^^^^^                    ^^^^^^^
//                       these types are different
implicitly[santorin.SuitableFood =:= Grass] // -- fails

val tornado = new Horse
val tornado2 = new Horse

implicitly[tornado.SuitableFood =:= tornado2.SuitableFood] // compiles!
//                     ^^^^^^^                    ^^^^^^^
//                               Grass =:= Grass

implicitly[tornado.SuitableFood =:= Grass] // compiles

santorin: Animal 的 eat 方法的签名如下：

def eat(food: santorin.SuitableFood) // SuitableFood is path-dependent

santorin.SuitableFood 是Food 和Animal#SuitableFood 的子类型

HorseFood 是 Food 和 Grass 的子类型，但不是 santorin.SuitableFood 或 Animal#SuitableFood 的子类型

implicitly[HorseFood <:< Food]
implicitly[HorseFood <:< Grass]
implicitly[HorseFood <:< santorin.SuitableFood]//  -- fails
implicitly[HorseFood <:< Animal#SuitableFood]//  -- fails

这就是为什么在 HorseFood 上调用方法 eat 也会失败。因为HorseFood 不是santorin.SuitableFood 的子类型。

这就是为什么以下工作：

santorin.eat((new HorseFood).asInstanceOf[santorin.SuitableFood])