Question

我正在考虑如何使用抽象方法编写抽象基类，该抽象方法将采用一个两个Int值。类似的东西：

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

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

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

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

Answer 1

通常，只需使用重载方法即可。然后在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
  }
}

抽象基类与抽象方法将采用一个或两个值（Scala）

1 个答案: