Class 伴侣 object 与案例 class 本身

Question

我读了这个声明：

通过使用 User.getClass，您指的是 class 伴侣 object，默认情况下 Scala 为案例 class 创建，而不是案例 class 本身。

要获得案例 class 的 class object，请使用 classOf[User]。

使用同伴object的class哪里可以解卡？ 我本以为 - 在这里显示我的无知 - 他们会是一样的。

Answer 1

Java 有一种叫做 static 的方法

public class Foo {

  private int a:

  public Foo(a) { this.a = a; }

  public int getA() { return a; }

  static public String getB() { return "B"; }
}

它就像一个方法但没有附加到实例

var foo = new Foo(10);
foo.getA(); // method attached to foo, its value depends on foo

Foo.getB(); // method attached to class but not particular instance 

这些 static 方法用于存储全局变量（不推荐）或不依赖于 object 的无状态函数 - 例如工厂和其他实用程序。 这些方法可以访问实例的私有/受保护成员，并且实例可以访问私有/受保护的 static 方法 - 因此您可以限制可见性，就好像它们在 object 内部一样，即使它们不是（Java 的反射将它们的方法视为它们有null作为this ）。

在 Scala 中，我们不想区分 static 和非静态方法，因此我们决定执行以下操作：

• 创建一个单独的 object 可以存储这些方法
• 确保这个 object 可以访问实例成员，反之亦然
• 具有相似的名称以将此object与其他object来

这就是我们如何找到同伴 object 的。

class Foo(val a: Int)
object Foo {
  val b = "B"
}

val foo = new Foo(10)
foo.a // this is normal method
foo.getClass // this would return Foo
class[Foo]   // same as above

Foo.getClass // this would return Foo$
classOf[Foo.type] // same as above

getClass是您可以在任何 object 上调用的方法 - 因为foo和Foo有不同的类，它们会为getClass返回不同的值。

任何值都可以用.type描述它们的类型，所以foo.type将是foo变量 ( Foo ) 的类型，而Foo.type将是Foo object 的类型，它是Foo class 的伴侣（在字节码中称为Foo$ ） .

从companion object 存在的原因可以看出，Foo 和它的companion 没有相同的（实例）方法，所以它们不能有相同的接口，所以它们不能是相同的类型。

当涉及case class es 时，他们只是自动创建一个伴侣 object（如果它不存在）并根据其构造函数在其中生成一些方法：例如apply ， unapply 。

Answer 2

通常， class A和它的同伴 object A定义了不同的（不相关的）static 类型，即A和A.type

class A
object A

implicitly[A <:< A.type] // doesn't compile
implicitly[A.type <:< A] // doesn't compile

val a: A.type = new A // doesn't compile, we can't assign a class instance to an object variable
val a1: A = A // doesn't compile, we can't assign an object to a class variable

同样，它们有不同的运行时类（字节码中的不同表示），即A和A$

classOf[A] == Class.forName("A") // true
classOf[A.type] == Class.forName("A$") // true

classOf[A].isAssignableFrom(classOf[A.type]) // false
classOf[A.type].isAssignableFrom(classOf[A]) // false

有时，当有原因时，伙伴可以在类型上达成一致（尽管很少做出这样的设计决定）。 示例： https://github.com/apache/spark/blob/v3.3.1/sql/catalyst/src/main/scala/org/apache/spark/sql/types/LongType.scala#L56

class A
object A extends A

// implicitly[A <:< A.type] // doesn't compile
implicitly[A.type <:< A] // compiles

classOf[A].isAssignableFrom(classOf[A.type]) // true
classOf[A.type].isAssignableFrom(classOf[A]) // false

// val a: A.type = new A // doesn't compile
val a1: A = A // compiles

或者

trait B
class A extends B
object A extends B

val b: B = new A
val b1: B = A