你怎么能继承一个通用的工厂方法？

Question

假设你有一个Person类,并通过扩展例如ArrayBuffer为它创建一个集合类:

class Persons extends ArrayBuffer[Person] {
// methods operation on the collection
}

现在,使用ArrayBuffer,可以在随播对象上使用apply()方法创建一个集合,例如:

ArrayBuffer(1, 2, 3)

您希望能够对人员做同样的事情,例如:

Persons(new Person("John", 32), new Person("Bob", 43))

我的第一个直觉是扩展ArrayBuffer伴侣对象并免费获取apply()方法.但似乎你无法扩展对象.(我不太清楚为什么.)

接下来的想法是使用apply()方法创建一个Persons对象,该方法调用ArrayBuffer的apply方法:

object Persons {
    def apply(ps: Person*) = ArrayBuffer(ps: _*) 
}

但是,这会返回一个ArrayBuffer [Person]而不是Persons.

在scaladoc和ArrayBuffer的源代码中进行了一些挖掘之后,我提出了以下内容,我认为这将使Persons对象从GenericCompanion继承apply():

编辑:

object Persons extends SeqFactory[ArrayBuffer] {
    def fromArrayBuffer(ps: ArrayBuffer[Person]) = {
        val persons = new Persons
        persons appendAll ps
        persons
    }

    def newBuilder[Person]: Builder[Person, Persons] = new ArrayBuffer[Person] mapResult fromArrayBuffer
}

但是,它给出以下错误消息:

<console>:24: error: type mismatch;
 found   : (scala.collection.mutable.ArrayBuffer[Person]) => Persons
 required: (scala.collection.mutable.ArrayBuffer[Person(in method newBuilder)])
=> Persons
        def newBuilder[Person]: Builder[Person, Persons] = new ArrayBuffer[Perso
n] mapResult fromArrayBuffer
             ^

也许这应该不鼓励我走得更远,但我正在学习Scala,我真的很想让这个工作.请告诉我,如果我走错了路.:)

Answer 1

ArrayBuffer[Person]您可以使用pimp my library 模式，而不是直接扩展。这个想法是使Persons和ArrayBuffer[Person]完全可互换。

class Persons(val self: ArrayBuffer[Person]) extends Proxy {
   def names = self map { _.name }

   // ... other methods ...
}

object Persons {
   def apply(ps: Person*): Persons = ArrayBuffer(ps: _*)

   implicit def toPersons(b: ArrayBuffer[Person]): Persons = new Persons(b)

   implicit def toBuffer(ps: Persons): ArrayBuffer[Person] = ps.self
}

Persons 伴随对象中的隐式转换允许您在拥有 Persons 引用时使用任何 ArrayBuffer 方法，反之亦然。

例如，你可以这样做

val l = Persons(new Person("Joe"))
(l += new Person("Bob")).names

请注意，这l是 a Persons，但您可以调用ArrayBuffer.+=它的方法，因为编译器会自动添加对 的调用Persons.toBuffer(l)。该方法的结果+=是ArrayBuffer，但您可以调用Person.names它，因为编译器插入了对 的调用Persons.toPersons。

编辑：

您可以使用更高级的类型来推广此解决方案：

class Persons[CC[X] <: Seq[X]](self: CC[Person]) extends Proxy {
   def names = self map (_.name)
   def averageAge = {
      self map (_.age) reduceLeft { _ + _ } / 
            (self.length toDouble)
   }
   // other methods
}

object Persons {
   def apply(ps: Person*): Persons[ArrayBuffer] = ArrayBuffer(ps: _*)

   implicit def toPersons[CC[X] <: Seq[X]](c: CC[Person]): Persons[CC] =
         new Persons[CC](c)

   implicit def toColl[CC[X] <: Seq[X]](ps: Persons[CC]): CC[Person] = 
         ps.self
}

这允许你做类似的事情

List(new Person("Joe", 38), new Person("Bob", 52)).names

或者

val p = Persons(new Person("Jeff", 23))
p += new Person("Sam", 20)

请注意，在后一个示例中，我们调用的+=是Persons. 这是可能的，因为Persons“记住”底层集合类型并允许您调用该类型中定义的任何方法（ArrayBuffer在本例中，由于 的定义Persons.apply）。