0

我想做如下的事情：

class A[T] (_arr: Array[T]) { var arr = _arr }
class C {
  def foo[T <: A[_]](a: Array[T]){
    var ele1 = a(0)
    var ele2 = a(1)
    for(i <- 0 until ele1.arr.length) {
      val temp = ele1.arr(i)
      ele1.arr(i) = ele2.arr(i)
      ele2.arr(i) = temp
    }
  }
}

但我收到以下编译器错误：

<console>:15: error: type mismatch;
 found   : temp.type (with underlying type Any)
 required: _$1
             ele2.arr(i) = temp
                           ^

我不确定为什么 ele1.arr(i) = ele2.arr(i) 会起作用而 ele2.arr(i) = temp 不会。

编辑：根据雷克斯的建议，我将其更改为以下内容：

class A[T] (_arr: Array[T]) { var arr = _arr }
class C {
  def foo[T, B <: A[T]](b: Array[B]){
    var ele1 = b(0)
    var ele2 = b(1)
    for(i <- 0 until ele1.arr.length) {
      val temp = ele1.arr(i)
      ele1.arr(i) = ele2.arr(i)
      ele2.arr(i) = temp
    }
  }
}

现在编译得很好。但是当我做一个测试用例时，如下：

object Test extends App {
  var p = Array.ofDim[A[Int]](2)
  var g1 = new A[Int](Array(1, 2, 3, 4, 5))
  var g2 = new A[Int](Array(6, 7, 8, 9, 10))
  p(0) = g1
  p(1) = g2

  (new C).foo(p)
  p.foreach{ x => println(x.arr.deep.mkString(",")) }
}

我收到以下编译器错误：

src/Test.scala:22: error: inferred type arguments [A[Int],Nothing] do not conform to method foo's type parameter bounds [B <: A[T],T]
  (new C).foo(p)
          ^
src/Test.scala:22: error: type mismatch;
 found   : Array[A[Int]]
 required: Array[B]
  (new C).foo(p)
              ^
two errors found

我知道我可以做 (new C).fooInt, A[Int]，但我真的很想让编译器推断它。否则，它有点违背了我正在做的很多事情的目的。

4

1 回答 1

4

我不明白你为什么在这里使用通配符而不是参数化元素类型。您正在使编译器蒙蔽，并使其更难确保您正在做一些明智的事情。特别是，它意识到由于数组是不变类型的，ele1.arr(i)并且ele2.arr(i)是相同的类型，因此可以被分配。但是，当您分配给 时temp，它意识到它不知道该类型实际上可能是什么，因此它推断Any，然后当然不会重新放入数组中，因为它实际上 Any不是; 它只是忘记了它应该是什么。

class C {
  def foo[T, B <: A[T]](b: Array[B]){
    var ele1 = b(0)
    var ele2 = b(1)
    for(i <- 0 until ele1.arr.length) {
      val temp = ele1.arr(i)
      ele1.arr(i) = ele2.arr(i)
      ele2.arr(i) = temp
    }
  }
}

允许编译器从头到尾知道类型，这让编译器很开心，你也更安全。

于 2013-03-30T21:05:41.200 回答