相同的方法，不同的参数类型，一次实现

Question

我有一个（Java）类，其操作如下：

abstract class Holder {
    def set(i: Int): Unit
    def set(s: String): Unit
    def set(b: Boolean): Unit
    ...
}

本质上，所有类都执行相同的任务，但只是采用不同的参数类型。我很想创建一个通用的 Accessor[T] 来执行类似的操作：

class Accessor[T](holder: Holder) { 
    def set(value: T) { holder.set(value) }
}

...但这给出了：

<console>:16: error: overloaded method value set with alternatives:
  (s: String)Unit <and>
  (i: Int)Unit
  (b: Boolean)Unit
 cannot be applied to (T)
       def set(value: T) { holder.set(value) }

有什么出路吗？

Answer 1

使用反射。

class Setter(obj: AnyRef) {
  val clazz = obj.getClass
  def set[T : Manifest](v: T): Boolean = try {
      val paramType = manifest[T].erasure
      val method = clazz.getMethod("set", paramType)
      method.invoke(obj, v.asInstanceOf[AnyRef])
      true
  } catch {
      case ex => false
  }
}

val holder = ..
val setter = new Setter(holder)
setter.set(5) // returns true
setter.set(1.0) // double not accepted, returns false

Scala 中有一个实验性的快捷方式，但在 2.8.0 发布之前它被删除了。

Answer 2

我认为匹配应该很好

def set(value: T) {
    value match {
         case s: String => holder.set(s)
         case i: Int => holder.set(i)
         case b: Boolean => holder.set(b)
    }
}

Answer 3

我不完全理解你的用例，但是你可能会尝试做的一件事——如果性能不是最重要的——是创建一个包装类，为你转换为通用形式，然后让你的所有方法都采用该包装类（具有适当的隐式转换）。例如：

class Wrap(val data: String)
implicit def wrapString(s: String) = new Wrap(s)
implicit def wrapBoolean(b: Boolean) = if (b) new Wrap("T") else new Wrap("F")
implicit def wrapLong(l: Long) = new Wrap(l.toString+"L")

class User {
  private[this] var myData = ""
  def set(w: Wrap) { println("Setting to "+w.data); myData = w.data }
}

val u = new User
u.set(true)
u.set(50L)
u.set(50)     // Int gets upconverted to Long for free, so this works
u.set("Fish")
// u.set(3.14159)  // This is a type mismatch

这有点像采用 Any ，只不过您可以根据自己的喜好限制类型，并指定转换为您想要的任何通用表示形式。但是，如果不存在通用形式，那么我不确定您的意思是代码每次都在执行相同的操作。 （也许您的意思是您可以设想一个自动生成代码的宏（或另一个程序）——Scala 没有内置这种支持，但您当然可以编写一个生成 Scala 代码的 Scala 程序。）

Answer 4

回顾到目前为止收集到的结果，建议了几个解决方案：

• 使用模式匹配（导致处理不同参数类型的不同策略的碎片化）
• 使用反射（对于理想情况下应该是的东西来说代价昂贵超级快）
• ...并添加我最终实现的一个：为每种类型的参数编写一个适配器。

更准确地说，整个练习就是围绕京都内阁编写一个包装。京都内阁具有将字节数组键与字节数组值以及字符串键与字符串值关联的方法。然后它基本上复制了处理字节数组和字符串的键和值的大部分操作。

为了围绕京都橱柜的 DB 类创建 Map 包装器，我定义了一个特征 TypedDBOperations[T]，其中 T 是参数类型，并实现了两次。如果我现在构造一个 Map[Array[Byte], Array[Byte]]，隐式转换将自动为其分配正确的 TypedDBOperations 实例，调用 DB 类的基于 Array[Byte] 的操作。

这是我一直在谈论的特征：

trait TypedDBOperations[K,V] {
  def get(db: DB, key: K): V
  def set(db: DB, key: K, value: V): Boolean
  def remove(db: DB, key: K): Boolean
  def get(cursor: Cursor): (K, V)
}

这些是两种类型的键值组合的实现：

  implicit object StringDBOperations extends TypedDBOperations[String] {
    def get(cursor: Cursor) = {
      val Array(a, b) = cursor.get_str(false)
      (a, b)
    }
    def remove(db: DB, key: String) = db.remove(key)
    def set(db: DB, key: String, value: String) = db.set(key, value)
    def get(db: DB, key: String) = db.get(key)
  }

  implicit object ByteArrayOperations extends TypedDBOperations[Array[Byte]] {
    def get(cursor: Cursor) = {
      val Array(a, b) = cursor.get(false)
      (a, b)
    }
    def remove(db: DB, key: Array[Byte]) = db.remove(key)
    def set(db: DB, key: Array[Byte], value: Array[Byte]) = db.set(key, value)
    def get(db: DB, key: Array[Byte]) = db.get(key)
  }

不是有史以来最令人满意的解决方案，但它完成了工作。再次注意，仍然存在相当多的重复，但似乎没有办法消除它。