1

根据我在 X 中传递的对象类型，我需要使用 apply 方法。我可以指定要使用的修饰符（Y 或 Z）。我需要使用这样的“跟随”函数的语法：

(object of type B) following Y

或者

(object of type C) following Z

代码如下所示：

trait A 
{
    def following(modifier: X) = modifier(this)
}
case class B() extends A{}
case class C() extends A{}
trait X {}
object Y extends X
{
    apply(obj: B):B = {}
    apply(obj: C):C = {}
}
object Z extends X
{
    apply(obj: B):B = {}
    apply(obj: C):C = {}
}

编译器在我实现“以下”功能的行中给出错误。我究竟做错了什么？

4

2 回答 2

3

我想你想要的是这样的：

    trait X {
        def apply[T](obj: T): T
    }

    trait A {
        def following(modifier: X) = modifier(this)
    }

    case class B() extends A
    case class C() extends A

    object Y extends X {
        override def apply[B](obj: B): B = { obj }
        override def apply[C](obj: C): C = { obj }
    }

    object Z extends X {
        override def apply[B](obj: B): B = { obj }
        override def apply[C](obj: C): C = { obj }
    }

不幸的是，我认为您不能有两个覆盖的 apply 方法，因此它不会编译。如果这是可能的，那么我也很乐意知道。你现在可以做的是使用一种应用模式匹配的方法：

    trait X {
        def apply[T](obj: T): T
    }

    trait A {
        def following(modifier: X) = modifier(this)
    }

    case class B() extends A
    case class C() extends A

    object Y extends X {
        override def apply[T](obj: T): T = {
            obj match {
                case o: B => obj
                case o: C => obj
            }
        }
    }

    object Z extends X {
        override def apply[T](obj: T): T = {
            obj match {
                case o: B => obj
                case o: C => obj
            }
        }
    }

您也可以通过其他方式获得完全相同的效果（包括语法）。在我看来，它更清晰，更容易理解：

    sealed trait X
    case class Y() extends X
    case class Z() extends X

    trait A[T] {
        def following(modifier: X): T
    }

    case class B() extends A[B] {
        override def following(modifier: X) = modifier match {
            case o: Y => this
            case o: Z => this
        }
    }

    case class C() extends A[C] {
        override def following(modifier: X) = modifier match {
            case o: Y => this
            case o: Z => this
        }
    }
于 2013-10-30T14:47:29.887 回答
1

您做错了几件事：

  1. 您apply在 Y 和 Z 中的定义必须有def。
  2. trait X 需要apply定义方法，尽管只是作为抽象方法。
  3. following需要在 B 和 C 中重写，以便编译器知道要调用 X 中的哪个重载方法。
  4. following需要在 A 中是抽象的。

您正在实现访问者模式。我建议找一本四人合一的书，并从那里的例子开始工作。

于 2013-10-30T14:16:48.217 回答