Question

我试图将构造函数重载到一个类，以便它可以接受两种不同类型对象的列表：

class myClass(){
  var someStrings: List[String]=List[String]()
  println("hello!")

  def this(strings : List[String])={
    this()
    this.someStrings=strings
  }

  def this(ints: List[Int])={
    this()
    this.someStrings=ints.map(x => x.toString)
  }
}

在这种情况下，接受一个int或字符串列表，并将字符串列表保存到变量someStrings。上面的代码不起作用：

error: double definition:
constructor myClass: (strings: List[String])myClass at line 12 and
constructor myClass: (ints: List[Int])myClass at line 17
have same type after erasure: (strings: List)myClass
             def this(ints: List[Int])={
             ^

在scala中有更好的方法吗？（除了列出[任何]列表并测试元素）

谢谢！

Answer 1

在伴侣对象上创建函数，以可在编译时检查的类型安全方式为您构造：

class myClass(){
  var someStrings: List[String]=List[String]()
  println("hello!")
}

object myClass {
  def fromStrings(strings: List[String]) = {
    val c = new myClass
    c.someStrings = strings
  }
  def fromInts(ints: List[Int]) = {
    val c = new myClass
    c.someStrings = ints.map(_.toString)
  }
}

object Usage {
  val c1 = myClass.fromStrings(List("a","b","c"))
  val c2 = myClass.fromInts(List(1,2,3))
}

我建议您在编译时检查类型，而不是在运行时避免重载或在运行时检查类型

Answer 2

这就是DummyImplicit的用途：

def this(strings: List[String])={
  this()
  this.someStrings=strings
}

def this(ints: List[Int])(implicit d: DummyImplicit)={
  this()
  this.someStrings=ints.map(x => x.toString)
}

这使得构造函数（即JVM看到的）MyClass(List)和MyClass(List, DummyImplicit)的签名被删除，因此允许重载。

然而，正如@stew所说，在这种情况下避免过载可能是个更好的主意。

Answer 3

除了另一个答案，你可以做的另一件事是使用数组。数组的类型信息保留在运行时，因此您可以根据类型参数进行重载。

class myClass() {
  var someStrings: Array[String] = Array[String]()
  println("hello!")

  def this(strings: Array[String]) = {
    this()
    this.someStrings = strings
  }

  def this(ints: Array[Int])={
    this()
    this.someStrings = ints.map(x => x.toString)
  }
}

我认为阵列未得到充分利用

是否可以重载接受scala中列表的构造函数？

3 个答案: