覆盖配套对象值和Scala MatchError

Question

有人可以澄清为什么下面的代码导致MatchError？ MatchError在这种情况下意味着什么？

class A { 
    def g = A.f 
} 

object A { 
    val f = "Object A" 
} 


class B extends A { 
    override val A.f = "Object B" 
} 

val b = new B 
b.g 

鉴于这种不工作，有没有办法来覆盖同伴对象VAL或DEF与此类似？

Answer 1

首先，为什么你看到MatchError。对象（A.f）上的值被认为是一个稳定的标识符（正如Scala参考所述，“稳定的成员是由对象定义或非易失性类型的值定义引入的成员”）。

这里的导电型测量仪输出的样子：

object A extends scala.AnyRef { 
    ... 
    private[this] val f: String = "Object A"; 
    <stable> <accessor> def f: String = A.this.f 
} 

当在分配使用的，编译器“desugars”这个稳定标识符的分配（它是稳定的必要条件）到模式匹配：

<synthetic> private[this] val x$1: Unit = ("Object B": String("Object B") @unchecked) match { 
    case A.f =>() 
} 

它不能匹配“对象B”与模式“对象A”，所以它会抛出MatchError。

给你更大的问题：你不能/不应该覆盖伴侣对象上的值和方法。多态性适用于类及其实例，而不适用于静态方法或值。可能有更好的方式来思考你的程序，它不会覆盖伴侣对象的vals/defs。

Answer 2

这很有趣！如果你把类定义成一个文件，并使用scalac -print test.scala编译它，你会看到这样的事情，

[[syntax trees at end of     cleanup]] // scala 
package <empty> { 
    class A extends Object { 
    def g(): String = A.f(); 
    def <init>(): A = { 
     A.super.<init>(); 
    () 
    } 
    }; 
    object A extends Object { 
    private[this] val f: String = _; 
    <stable> <accessor> def f(): String = A.this.f; 
    def <init>(): A.type = { 
     A.super.<init>(); 
     A.this.f = "Object A"; 
    () 
    } 
    }; 
    class B extends A { 
    <synthetic> private[this] val x$1: runtime.BoxedUnit = _; 
    def <init>(): B = { 
     B.super.<init>(); 
     B.this.x$1 = { 
     case <synthetic> val x1: String = ("Object B": String("Object B")); 
     case5(){ 
      if (A.f().==(x1)) 
      { 
       val x2: String = x1; 
       matchEnd4(scala.runtime.BoxedUnit.UNIT) 
      } 
      else 
      case6() 
     }; 
     case6(){ 
      matchEnd4(throw new MatchError(x1)) 
     }; 
     matchEnd4(x: runtime.BoxedUnit){ 
      scala.runtime.BoxedUnit.UNIT 
     } 
     }; 
    () 
    } 
    } 
} 

这表明编译器创建一个类B与执行的匹配检查，看看该值初始化您用于覆盖val A.f等于原始值if (A.f().==(x1))。似乎不太有用的权利？如果它们不相等，则通过调用case6()来引发匹配错误。我们可以通过将class B的定义更改为override val A.f = "Object A"来进行确认。

class B extends A { 
     override val A.f = "Object A" 
} 

scala> val b = new B 
b: B = B@1fc6dc6 

那么如何解决它呢？你可以做到这一点，

class B extends A { 
     override def g = "Object B" 
} 
scala> val b = new B 
b: B = B@19bdb65 

scala> b.g 
res1: String = Object B 

或

class B extends A { 
     val f = "Object B" 
} 
scala> val b = new B 
b: B = B@1e5ed7b 

scala> b.f 
res0: String = Object B