Question

这是楼梯书中的一个例子：

object Example {
  class Queue[+T] private (
                          private[this] var leading: List[T],
                          private [this] var trailing: List[T]
                            ) {
    private def mirror: Unit = {
      if(leading.isEmpty) {
        while(!trailing.isEmpty) {
          leading = trailing.head :: leading
          trailing = trailing.tail
        }
      }
    }

    // cannot resolve symbol U
    def this[U >: T](xs: U*) = this(xs.toList, Nil)
    // Covariant type T occurs in contra-variant position
    def this(xs: T*) = this(xs.toList, Nil)

    def head: T = {
      mirror
      leading.head
    }

    def tail: Queue[T] = {
      mirror
      new Queue(leading.tail, trailing)
    }

    def enqueue[U >: T](x: U) = new Queue[U](leading, x :: trailing)

    def size = leading.size + trailing.size
  }   
}

我添加了这些内容：

    // cannot resolve symbol U
    def this[U >: T](xs: U*) = this(xs.toList, Nil)
    // Covariant type T occurs in contra-variant position
    def this(xs: T*) = this(xs.toList, Nil)

因为我需要一些公共构造函数来创建新的队列。但是这些构造函数中的每一个都存在问题（参见注释）。可以做些什么来解决它们？

更新

没有参数的构造函数似乎编译得很好：

def this() = this(Nil, Nil)

Answer 1

在Scala中，多个构造函数的首选替代方法是使用apply方法创建伴随对象：

object Queue {
  def apply[T, U <: T](xs: U*): Queue[T] = new Queue(xs.toList, Nil)
  def apply[T](xs: T*): Queue[T] = new Queue(xs.toList, Nil)
}

这样，您可以使用val q = Queue(1, 2, 3)（请注意缺少new）来实例化您的队列，就像使用Scala标准集合中的大多数数据结构一样。

我上面写的对象不会按原样编译，因为两个apply方法在擦除后具有相同的类型，这个问题有不同的方法，但在这个精确的例子中，我认为最好只是简单地获取第二个函数。

具有协变类型参数的类和Scala中的私有构造函数

更新

1 个答案: