0

我正在考虑如何使用一个抽象方法编写一个抽象基类，该方法将采用一个或两个Int值。就像是：

abstract class Foo {
  def doSomething(???): Unit
}

到目前为止，我能想到的最好的方法是将参数声明为 a ，该参数Vector[Int]将保存一个或两个值，或者可能更好地强制执行两个值的最大值 a Tuple2[Int, Int]。

我想这样做是因为我想在Actor系统内传递算法，并且我希望某些消息强制执行算法的类型，而不是传递一个Any，因此是抽象基类。

这是最好的方法，还是有更好的方法？

4

1 回答 1

6

通常，这将通过重载方法来完成。然后在调用 on 方法时Bar，他们可以传入一两件事：

abstract class Foo {
  def doSomething(a: Int): Int
  def doSomething(a: Int, b: Int): Int
}

class Bar extends Foo {
  def doSomething(a: Int): Int = a
  def doSomething(a: Int, b: Int): Int = a * b
}

或者，使用默认参数（仍然允许您这样做new Bar().doSomething(5)）

abstract class Foo {
  def doSomething(a: Int, b: Int = 1): Int
}

class Bar extends Foo {
  def doSomething(a: Int, b: Int): Int = a * b
}

但听起来您想以一种始终调用相同Foo方法的方式执行此操作，因此在这种情况下，您可以对参数执行多态性：

trait Thing
case class Thing1(a: Int) extends Thing
case class Thing2(a: Int, b: Int) extends Thing

abstract class Foo {
  def doSomething(t: Thing): Int
}

class Bar extends Foo {
  def doSomething(t: Thing): Int = t match {
    case Thing1(a) => a
    case Thing2(a, b) => a * b
  }
}

或者，因为你只有两个选择，你可以用一个做同样的事情Either：

abstract class Foo {
  def doSomething(t: Either[Int, (Int, Int)]): Int
}

class Bar extends Foo {
  def doSomething(t: Either[Int, (Int, Int)]): Int = t match {
    case Left(a) => a
    case Right((a, b)) => a * b
  }
}
于 2012-08-10T02:00:35.697 回答