崔鹏飞的Octopress Blog

Scala中的语言特性是如何实现的(1)

| Comments

Scala可以编译为Java bytecode和CIL,从而在JVM和CLI之上运行。Scala有很多在Java和C#的世界中显得陌生的语言特性,本文将分析这些语言特性是如何实现的。

object

Scala中可以像这样创建object:

1
2
3
4
5
object HowIsObjectImplementedInScala {
  def printSomething() {
    println("printSomething")
  }
}

然后在代码的其他地方调用printSomething,一个object究竟是什么东西呢? 我们将这段Scala编译为Java bytecode,然后反编译为Java,会发现编译器为HowIsObjectImplementedInScala这个object生成了两个类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public final class HowIsObjectImplementedInScala
{
  public static void printSomething()
  {
    HowIsObjectImplementedInScala..MODULE$.printSomething();
  }
}

public final class HowIsObjectImplementedInScala$
{
  public static final  MODULE$;

  static
  {
    new ();
  }

  public void printSomething()
  {
    Predef..MODULE$.println("printSomething");
  }

  private HowIsObjectImplementedInScala$()
  {
    MODULE$ = this;
  }
}

第一个类只包含一个静态方法,其实现依赖于第二个叫做HowIsObjectImplementedInScala$的类。

HowIsObjectImplementedInScala$是一个单例,其静态块实例化自己并把this赋值给MODULE$这个public static的成员,从而可以被外界访问。

同样,我们可以把这段代码编译为CIL,然后反编译为C#:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public sealed class HowIsObjectImplementedInScala
{
  public static void printSomething()
  {
    HowIsObjectImplementedInScala$.MODULE$.printSomething();
  }
}

public sealed class HowIsObjectImplementedInScala$ : ScalaObject
{
  public static HowIsObjectImplementedInScala$ MODULE$;
  public override void printSomething()
  {
    Predef$.MODULE$.println("printSomething");
  }
  private HowIsObjectImplementedInScala$()
  {
    HowIsObjectImplementedInScala$.MODULE$ = this;
  }
  static HowIsObjectImplementedInScala$()
  {
    new HowIsObjectImplementedInScala$();
  }
}

和Java代码大同小异,除了静态构造和某几个关键字外,基本一样。一个object就是一个Scala编译器帮我们实现的singleton。

var和val

var:可变。val:不可变。关于这两个关键字何时该使用哪一个,这里不做讨论,我们只是观察这二者在编译后是如何被表示的。

这段Scala代码:

1
2
3
4
5
6
7
8
9
10
class HowAreVarAndValImplementedInScala {
  var v1 = 123
  val v2 = 456

  def method1() = {
    var v3 = 123
    val v4 = 456
    println(v3 + v4)
  }
}

定义了两个字段一个var,一个val,方法中定义了两个局部变量,一个var,一个val。

编译为Java bytecode并反编译之后:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public class HowAreVarAndValImplementedInScala
{
  private int v1 = 123;
  private final int v2 = 456;

  public int v1()
  {
    return this.v1;
  }

  public void v1_$eq(int x$1) { this.v1 = x$1; }

  public int v2() { return this.v2; }

  public void method1() {
    int v3 = 123;
    int v4 = 456;
    Predef..MODULE$.println(BoxesRunTime.boxToInteger(v3 + v4));
  }
}

声明为字段的v1和v2,一个是普通字段,另一个则被标记为final。编译器为v1生成了getter和setter,为v2则只有getter,因为v2作为immutable的字段是不可以被重新赋值的。

有趣的是方法中的局部变量都是普通的变量,没有被final修饰。

再来看这段Scala编译为CIL再反编译为C#之后的样子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class HowAreVarAndValImplementedInScala : ScalaObject
{
  private int v1;
  private int v2;

  public override int v1()
  {
    return this.v1;
  }

  public override void v1_$eq(int x$1)
  {
    this.v1 = x$1;
  }

  public override int v2()
  {
    return this.v2;
  }

  public override void method1()
  {
    int v3 = 123;
    int v4 = 456;
    Predef$.MODULE$.println(v3 + v4);
  }

  public HowAreVarAndValImplementedInScala()
  {
    this.v1 = 123;
    this.v2 = 456;
  }
}

有一个明显的问题,v2没有标为readonly(C#世界中用于声明变量不可以重新赋值的关键字),这是compiler的bug吗?

除此之外,和Java代码一致。但是有趣的是代码中的所有public方法(包括上一段演示object的代码)都被标为了override,原因不明。

小结

本来以为研究这么简单的两个语言特性不会有啥收获,仅仅是反编译一下,看看compiler都做了啥,满足下好奇心罢了。

结果还是有意外收获,我在反编译后的代码中发现了三个有趣的问题:

  • 在Scala中被声明为val的v4为什么在反编译的Java中不是final的呢?
  • 在Scala中被声明为val的v2为什么在反编译的C#中不是readonly的呢?
  • 为什么反编译出来的C#代码中的实例级公开方法都是标有override的呢?

为什么呢?为什么呢?为什么呢?答案下期揭晓。

Comments