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的呢？
为什么呢？为什么呢？为什么呢？答案下期揭晓。