首页 文章

接受任何将特征扩展为scala中的参数的case类

提问于
浏览 次
4

我需要一个函数来接受任何扩展特征的case类 . 举个例子

假设有一个特征

trait Action {
    def execute(param: Parameters)
}

并且可以传递以下参数，具体取决于它的操作类型

trait Parameters
case class A(x: String, y: Double) extends Parameters
case class B(x: Int, y:String, z: Double) extends Parameters

用户应该能够指定它想要的参数

class Action1 extends Action {
    override def execute(param: A)
}

class Action2 extends Action {
    override def execute(param: B)
}

在打电话的时候

def run(t: Action) {
    t.execute(new A("a", 1.0))
}

怎么做到这一点？当我实现Action1时，它说我会得到我们无法覆盖的错误，因为trait说execute方法接受Parameters，但是在覆盖时，我们需要一个扩展Parameters的类 .

scala

2 回答

  • 2

    你需要考虑的是为什么你需要 Action 开始使用 execute 方法 . 可能你的代码中有其他类似的东西：

    def executeAll(actions: Seq[Action], params: Parameters) = 
    actions.foreach { _.execute(params) }

    请注意，此处 actions 列表可以包含不同类型的操作 . 如果其中一些除了 A 类型的参数，并且有些需要它是 B 类型，它将无法工作，因为你的 params 参数不能同时存在 .

    出于这个原因，你不能覆盖一个方法来在子类中采用不同的参数类型（实际上，你可以，但是类型必须是原始类型的超类，而不是子类 . 他们说函数是逆变的这个reas的参数类型，但我离题了 .

    如果 Action1 和 Action2 实际上可以实际处理它们的参数，通过trait接口而不要求它们是特定类型，那么解决方案很简单：只需将覆盖方法的声明更改为 override def execute(params: Parameters) .

    如果不是这种情况， Action1 只能处理 A 类型的参数，那么（1）可能（虽然，不一定）你的设计有问题，（2）你必须使用参数化解决方案，正如另一个答案所示 . 但是你必须改变所有的地方，也处理 Action ：

    def executeAll[T <: Parameters](actions: Seq[Action[T]], params: T) = ...

    此声明限制 params 参数的类型以匹配列表中的操作所期望的内容，因此错误地不会使用 B 调用 Action1.execute .

    现在，正如你在其他答案的评论中提到的那样，你不能混合不同类型的动作，因为它没有意义：它们本质上是不同的类 . 如果您不打算使用 execute 方法，并且只想传递一些代码周围的不同操作列表，则可以使用通配符语法：

    val actions: List[Action[_] = List(Action1(...), Action2(...))

    再次，此列表可以作为任何类型的操作的通用容器，但您不能使用它一般地应用 execute 方法，因为这将要求参数同时具有不同类型 .

    回复于
  • 4

    一种方法是参数化 Action .

    trait Action[T <: Parameters] {
  def execute(param: T)
}

    然后

    class Action1 extends Action[A] {
  override def execute(param: A)
}

class Action2 extends Action[B] {
  override def execute(param: B)
}

def run[T <: Parameters](t: Action[T], param: T) {
  t.execute(param)
}

// You don't need new for a case class
run(new Action1, A("a", 1.0))

    你必须在这里稍微修改一下 run 因为你可以单独通过子类来请求't get what you' . 参数类型是contravariant，这意味着函数 A => T 是函数 Parameters => T 的超类 . 这是因为虽然 A 类型的任何参数都适用于 A => T 和 Parameters => T ，但只有 Parameters 类型的某些参数适用于 A => T ，而所有这些参数都适用于 Parameters => T .

    回复于

相关问题