0

对于 Scala 大师来说，这可能是一件容易的事。我正在阅读类型绑定约束并想知道我是否遗漏了一些东西，因为我看到了一个稍微出乎意料的行为。假设我们在这样的层次结构中有三种类型 A、B、C，我们正在尝试使用类型边界：

class A {
}

class B extends A {
}

class C extends B {
}

class MyList1 { // T super B
  def add[T >: B](a: T): Unit = {}
}

class MyList2 { // T extends B
  def add[T <: B](a: T): Unit = {}
}

class MyList3[T >: B] { // T super B
  def add(a: T): Unit = {}
}

class MyList4[T <: B] { // T extends B
  def add(a: T): Unit = {}
}

object BoundsClass {

  def main(args: Array[String]) {
    val l1 = new MyList1
    l1.add(new A) 
    l1.add(new B)
    l1.add(new C) // why is this allowed??

    val l2 = new MyList2
    // l2.add(new A) // not allowed (OK)
    l2.add(new B)
    l2.add(new C)

    val l3a = new MyList3[A]
    val l3b = new MyList3[B]
    // val l3c = new MyList3[C] // not allowed (OK)

    // val l4a = new MyList4[A] // not allowed (OK)
    val l4b = new MyList4[B]
    val l4c = new MyList4[C]
  }

}

除一种情况外，所有集合的行为均符合预期，请参见 l1.add(new C); 不会导致编译错误。为什么允许这样做？

谢谢！

4

2 回答 2

3

我并没有声称自己是 scala 大师，但我会对此进行尝试。

您已经按照 定义了类型层次结构A >: B >: C，因此您可以执行以下操作

val aa: A = new A
val ab: A = new B
val ac: A = new C

val bb: B = new B
val bc: B = new C

val cc: C = new C

就像你可以说val a: Any = new Whatever的。

因此，当您尝试将 a 添加new C到 时l1，它会被视为B实例，因为这是其自身最接近的可用版本，符合方法的类型边界。

于 2012-12-23T14:42:21.987 回答
0

以这种方式使用时，下限没有用。您不能强制值参数具有下限，因为根据Liskov 替换原则，您必须能够在需要类实例的任何地方使用子类的实例。因此，您的代码可以编译，因为new C可以将其视为B.

通常，由于这个原因，在方法的值参数上设置下限是没有用的。在您绑定类的类型参数的第二种情况下，下限肯定更有用。所有类型参数都在编译类型时解析，因此，您可以期望编译器在第二种情况下产生编译器错误。您可以在此处找到更具体的下限用法示例。

于 2012-12-23T22:50:16.850 回答