c# - Scala有没有类似于C#的显式接口(interface)实现？

Question

在 C# 中，您可以显式实现接口(interface)。然后只能通过将接口(interface)作为其静态类型的变量调用显式实现的方法。这使您可以避免名称/返回类型冲突，并根据 this 的静态类型提供同一方法的不同实现。

例如:

interface IFoo
{
    int DoSomething();
}

interface IBar
{
    string DoSomething();
}

class Impl : IFoo, IBar
{
    int IFoo.DoSomething() { /* Implementation for IFoo */ }
    string IBar.DoSomething() { /* A different implementation for IBar */ }
    public void DoSomething() { /* Yet another implementation for Impl */ }
}

你会如何在 Scala 中处理这种情况:

trait Foo {
    def doSomething(): Int
}

trait Bar {
    def doSomething(): String
}

class Impl extends Foo with Bar {
    /* only one "doSomething()" visible here (that of Bar?) */
    /* what now... ? */
}

Answer 1

如果您只是想让您的类遵循两个独立的不兼容接口(interface)，则必须改为编写包装器。例如，

implicit case class ImplAsFoo(impl: Impl) extends Foo {
  def asFoo = this
  def doSomething: Int = 5
}

现在你可以

impl.asFoo

在使用站点切换到 Foo 包装。

不过，在某些情况下，使用类型类模式来提供可插入功能可能更自然:

trait IFoo[A] { def doSomething: Int }
trait IBar[A] { def doSomething: String }

// These need to be companions so :paste if you're using REPL
class Impl { def doSomething { println("Hey!") } }
object Impl {
  implicit object FooImpl extends IFoo[Impl] { def doSomething = 5 }
  implicit object BarImpl extends IBar[Impl] { def doSomething = "salmon" }
}

def needsFoo[A <: Impl: IFoo](a: A) = implicitly[IFoo[Impl]].doSomething

scala> needsFoo(new Impl)
res1: Int = 5

scala> (new Impl).doSomething
Hey!

它不是完全相同的，但这也解决了具有不同实现的问题，而命名方案不会让您感到困惑。 (如果您需要使用 impl 对象来doSomething，您可以将它作为参数传递到处理这种情况的隐式对象中。)

如果您已经拥有特质，那么这当然对您没有帮助。但是，当您从头开始设计时，与其拥有一堆具有不兼容方法的特征，不如尝试使用类型类。

最后，如果你忍不住把一堆未类型化的东西混在一起，你需要从中挑选出 Foo，你必须发明更复杂的方案，如下所示:

trait CanBeFoo { def asFoo: Foo }
trait Foo { def doSomething: Int }

// :paste these two together
class Impl extends CanBeFoo {
  def doSomething { println("Ho!") } 
  def asFoo = ImplAsFoo(this)
}
case class ImplAsFoo(impl: Impl) extends Foo {
  def doSomething = 6
}

val myList = List("salmon", new Impl, new Foo { def doSomething = 4 })
def doIt(f: Foo) { println(f.doSomething) }
myList.foreach {
  case f: Foo => doIt(f)
  case cf: CanBeFoo => doIt(cf.asFoo)
  case _ => println("nuh-uh")
}

// Produces
// nuh-uh
// 6
// 4

您可能更喜欢中间 map :

myList.map{ case cf: CanBeFoo => cf.asFoo; case x => x }.foreach{
  case f: Foo => println(f.doSomething)
  case _ => println("nuh-uh")
}