Scala 函数变体和重写

Question

我在理解重载时方法的差异时遇到了一些问题。

虽然由于返回类型的协变性，这种方法可以完美地工作，

class Bla 
class Fasel extends Bla 

trait Test[A] {
 def tester(): Bla = new Bla
}

class FooTest[A](a: A) extends Test[A] {
 override def tester(): Fasel = new Fasel                                      
}

但即使函数在其内部是逆变的，这种方法也会失败。 参数类型。

class Bla 
class Fasel extends Bla 

trait Test[A] {
 def tester(a: Fasel): Bla = new Bla                                           
}

class FooTest[A](a: A) extends Test[A] {
 override def tester(a: Bla): Fasel = new Fasel
}

我在这里犯了什么错？有什么指点吗？

问候， 雷鸟

Answer 1

这里发生了两件事：

1. 函数和方法不是同样的事情
2. 方法的参数类型不是多态的。

您的tester方法是一个方法，不是Function1 >。可以使用下划线语法将其提升为函数：

val f = (new FooTest[String]).tester _ // Fasel => Bla

该函数的输入类型将是逆变的。 （不过，值得一提的是，函数无法参数化，并且还值得一提的是，我必须拥有 Foo 或 FooTest 的实例才能获取 tester 方法的函数对象。这当然是从第一个观察得出的！）

函数是一个对象，它不能被覆盖，因为这没有任何意义。方法可以被重写。然而，正如我上面所说，重写在方法的参数类型中不是多态的。例如：

class A {
  def foo(a : Any) = println("A: " + a)
}

class B extends A {
  override def foo(s : String) = println("B " + s) //will not compile!
}

上面示例中的两个方法是两个独立的方法：动态调度仅适用于方法目标（即调用它的对象）。

在上面的示例中，如果删除 override 声明，代码将编译。如果您运行以下命令：

(new B).foo(1)   //prints A 1
(new B).foo("s") //prints B s

这是因为，虽然这两个方法都称为 foo，但它们是完全不同的方法（即我已经重载 foo，没有覆盖它）。最好将其理解为方法的参数（包括其类型）构成该方法的唯一名称的一部分。仅当它们具有完全相同的名称时，一种方法才会覆盖另一种方法。

---

本质上，您混淆了问题中两个独立且不相关的事物，为了清楚起见，我将把它们写下来：

• Function1 上的方差注释定义了它对于一个事物的含义函数成为另一个函数的子类型（因此可分配给给定类型的引用）。
• 可以在子类上重写方法，并且语言规范概述了何时发生此类重写的规则。

Answer 2

规范的相关片段：

方法类型

方法类型在内部表示为 (Ps)U ，其中 (Ps) 是参数名称和类型的序列 (p1 :T1,. ..,pn :Tn) 对于某些 n≥0 和 U 是（值或方法）类型。此类型表示的命名方法采用 T1,...,Tn 类型的名为 p1, ..., pn 的参数，并返回 U 类型的结果.

方法类型不作为值类型存在。如果方法名称用作值，则其类型将隐式转换为相应的函数类型（第 6.26 节）。

覆盖

C 类的成员 M，匹配 (§5.1.3) 非私有成员 M′C 基类的 code> 据说会覆盖该成员。在这种情况下，重写成员 M 的绑定必须包含（第 3.5.2 节）被重写成员 M' 的绑定。

一致性

如果对于i = 1, ..., n且U，Ti ≡ Ti′符合U′ 则方法类型 (p1 : T1,...,pn :Tn)U 符合 (p1′ :T1′,...,pn′ :Tn′)U '.




包含

类类型 C 的某些复合类型中的声明或定义包含某些复合类型或类类型 C' 中同名的另一个声明，如果以下之一以下保留。

• 定义类型为 T 的名称 x 的值声明或定义包含定义类型为 T' 的 x 的值或方法声明，前提是 T < ;:T′.

Answer 3

您可以覆盖并将返回类型更改为子类型，但是虽然接受超类型作为参数将满足替换原则，但这是不允许的（这就像在java中一样）原因是您还可以重载方法（多个具有相同的方法）名称、不同的参数数量和类型），并且您的方法将被视为重载。我想这主要是 JVM 兼容性和合理规范的问题。重载已经使 scala 规范变得相当复杂。简单地将重写方法路由到具有更改签名的重载方法可能就足够了：

class FooTest[A] extends Test[A] {
   override def test(a: Fasel) : Fasel = test(a.asInstanceOf[Bla])
   def test(a: Bla) : Fasel = new Fasel
}

您可以做的是使类型参数逆变，提供的仅出现在逆变位置（简化，显示为参数类型而不是结果类型）但是这是完全不同的：

trait Test[-A] {
  // note the - before A. 
  // You might want to constraint with -A >: Fasel
  def tester(a: A) : Bla = new Bla
}

class FooTest extends Test[Bla] {
  override def tester(a: Bla): Fasel = new Fasel
}

val testOfBla: Test[Bla] = new FooTest
val testOfFasel: Test[Fasel] = testOfBla 
  // you can assign a Test[Bla] to a test[Fasel] because of the -A

Answer 4

在第二个示例中，Test 中的 tester() 签名声明了一个 Fasel 参数，但具有 FooTest 的重写签名code> tester() 使用 Bla 作为参数进行声明。由于根据 extend 的层次结构，Fasel 是 Bla 的子类型，这可能是错误的。