scala:比较内部类对象的类型

Question

我如何知道内部类的两个对象是否具有相同的运行时类型？
在下面的示例中，我希望看到 aa.getClass == a.Inner 和 ba.getClass == b.Inner 的类，但实际上它们都是 Outer.Inner 并且相等。

class Outer{
      class Inner{}
    }

    val a = new Outer
    val b = new Outer

    val aa = new a.Inner
    val ab = new a.Inner
    val ba = new b.Inner

    val res1 = aa.getClass == ba.getClass
    val res2 = aa.isInstanceOf[ab.type ]

    scala>      |      | defined class Outer

    scala> a: Outer = Outer@550a1967

    scala> b: Outer = Outer@5f9678e1

    scala> aa: a.Inner = Outer$Inner@70a36a66

    scala> ab: a.Inner = Outer$Inner@1dd6d4b7

    scala> ba: b.Inner = Outer$Inner@2e61d218

    scala> res1: Boolean = true

    scala> res2: Boolean = false

Answer 1

... aa.getClass == a.Inner and ba.getClass == b.Inner, but in fact they are both Outer.Inner and equal

这不是真的。 Inner是一个类成员并且对于它的父实例 Outer 是唯一的.这意味着 a和 b拥有自己独特的版本 Inner ，这是不兼容的类型。所以 a.Inner与 b.Inner 的类型不同，因此是 a.Inner永远不能等于 b.Inner .我不能为另一个分配一个:

scala> val z: a.Inner = aa       // aa is a.Inner, so this is ok
z: a.Inner = Outer$Inner@575d06dd

scala> val z: b.Inner = aa       // aa is not b.Inner, so it fails to compile
<console>:14: error: type mismatch;
 found   : a.Inner
 required: b.Inner
       val z: b.Inner = aa
                        ^

getClass只是在这里不是很有用。

我们可以通过反射来证明这一点:

import scala.reflect.runtime.universe._

def tpeOf[A](a: A)(implicit tt: TypeTag[A]) = tt.tpe

scala> tpeOf(aa) =:= tpeOf(ba) // different Outer parents
res24: Boolean = false

scala> tpeOf(aa) =:= tpeOf(aa) // Same instance
res25: Boolean = true

scala> tpeOf(aa) =:= tpeOf(ab) // Same Outer parent
res26: Boolean = true

另一方面，您可以使用 Outer#Inner指定您不关心哪个 Outer您的 Inner类型属于。

val x: Outer#Inner = aa
val x: Outer#Inner = ab
val x: Outer#Inner = ba

所以正如@BenReich 所说，你可以使用 aa.isInstanceOf[Outer#Inner]检查您是否有任何这些类型，它们都会返回 true .
ab.type意味着完全不同的东西。 ab.type是一个单例类型，只包含 ab .那么自然而然， aa.isInstanceOf[ab.type]一定是假的，因为 aa不是 ab ，无论它们是否都是 a.Inner .