关于scala中抽象类型类的初始化问题

Question

我定义了一个具有抽象类型的类，如下所示：

abstract class AbsCell2{
    type T
    val init: T
    private var value: T = {
         println("Hello "+init);
         init
    }
    def get : T = value
    def set(x : T) = { value = x}
}

现在我实例化一个 Int 类型的对象

scala> val cell = new AbsCell2{type T = Int ; val init = 10}
Hello 0
cell: AbsCell2{type T = Int} = $anon$1@969ebb

请注意 println 的输出。看来变量init还没有被初始化为10。注意scala的版本是2.9.0-1

Answer 1

我认为您正在寻找 Scala 的 早期初始化器，

scala> val cell = new {type T = Int ; val init = 10} with AbsCell2
Hello 10
cell: AbsCell2{val init: Int; type T = Int} = $anon$1@1efa9557

scala> cell.get
res0: cell.T = 10

早期初始化器允许您分配一个新对象并在之前设置一些特定字段类构造函数运行。在本例中，由于 value 取决于 init，因此我们使用早期初始化语法（new { val init = ... } with AbsCell2）首先设置init，以便类构造函数可以正确初始化value。

另请参阅这个问题：在 Scala 中，什么是“早期初始化器”？

Answer 2

从 val 更改为 def：

abstract class AbsCell2{
  type T
  def init: T
  private var value: T = {
     println("Hello "+init);
     init
  }
  def get : T = value
  def set(x : T) = { value = x}
}

它按预期工作：

scala> val cell = new AbsCell2{type T = Int ; def init = 10}
Hello 10
cell: AbsCell2{type T = Int} = $anon$1@4302df5

Answer 3

对于有关 new { type T = Int ; 之间差异的问题val init = 10 } with AbsCell2 和 new AbsCell2 { type T = Int ; val init = 10 }。

第一个是所谓的早期初始化器或预初始化字段（在《Scala 编程》中的“抽象成员”章节中提到）。它允许子类在超类之前初始化字段。叫。
在这种情况下，init在AbsCell2初始化之前就已经被设置为10了。

后一种是正常继承，它创建一个匿名类，然后扩展AbsCell2，就像：

 class AbsCell' extends AbsCell {
    type T = Int 
    val init = 10 
 }

但是，匿名类是在抽象类AbsCell2之后初始化的，所以init 在自身初始化时不可用，即 init 是 Type 的默认值，本例中为 0。因此，你在打印中得到0。

使用scalac -Xprint:all Test.scala，你会看到以下内容：

 abstract class AbsCell2 extends Object {
    <stable> <accessor> def init(): Object;
    ....
   def <init>(): AbsCell2 = {
    AbsCell2.super.<init>();
    AbsCell2.this.value = {
      scala.this.Predef.println("Hello ".+(AbsCell2.this.init()));
      AbsCell2.this.init()
    };
    ()
   }
 };

 // normal initialization
 final class anon$1 extends AbsCell2 {
    private[this] val init: Int = _;
    <stable> <accessor> def init(): Int = anon$1.this.init;
    ....
    def <init>(): <$anon: AbsCell2> = {
     anon$1.super.<init>();
     anon$1.this.init = 10;
     ()
   }
 };

 // early initialization
 final class anon$2 extends AbsCell2 {
   private[this] val init: Int = _;
   <stable> <accessor> def init(): Int = anon$2.this.init;
   ....
   def <init>(): <$anon: AbsCell2> = {
     val init: Int = 10;
     anon$2.this.init = init;
     anon$2.super.<init>();
     ()
   }
 }

从代码中我们可以看到，对于正常的初始化，init之后被设置为3超类AbsCell2的初始化，当AbsCell2.this.init()被调用时，它实际上引用了子类的init字段，并且3还没有设置，所以我们得到默认的类型值。相反，早期初始化首先设置初始化到3.然后调用超类初始化。