Question

在C＃中，您可以明确地实现接口。然后，只能通过将接口作为其静态类型的变量来调用明确实现的方法。这允许您避免名称/返回类型冲突，并根据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

如果您只是想让您的类遵循两个独立的不兼容接口，那么您必须编写包装器。例如，

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!

它不是完全相同，但这也解决了在没有命名方案绊倒你的情况下实现不同实现的问题。（如果您需要使用doSomething对象impl，则将其作为处理该案例的implicit object中的参数传递。）

如果你已经有了特质，那么当然这对你没有帮助。但是当你从头开始设计时，你可能会尝试输入类型，而不是使用不兼容的方法制作一堆特征。

最后，如果你无法帮助将一堆无用的东西混杂在一起，你需要选择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

您可能更喜欢中间地图：

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

Answer 2

不，这些是完全不兼容的基类型。当一个类扩展一个特征时，它将该特征作为其类型标识的一部分。它不能具有互不兼容的类型标识，就像任何类extends Foo with Bar（当你编写这些特征时）一样。

Scala是否有类似于C＃的显式接口实现？

2 个答案: