Scala入门：从HelloWorld开始【源码及编译】 Scala的HelloWorld 反编译scala HelloWorld
最近在学习Scala语言，虽然还没有完全学通， 但是隐约可以体会到Scala的简洁和强大。 它既能让程序员使用函数式编程， 也提供了全面的面向对象编程。 在刚刚开始读《Scala编程》的时候， 刚读了几页， 我就被Scala语言吸引住了， 所以就一直读下去。 在学习的过程中， 也会有一些感悟， 对于一些原理， 也会尽量搞明白。 所以打算一边学习， 一边写博客， 虽然目前还没有深入， 但是还是有很多东西值得写下来。
我们知道， Scala也是一种运行于Java虚拟机上的语言， 既然能够运行于虚拟机之上， 那么它必然可以编译成class文件， 因为虚拟机只认class文件。 所以， scalac编译器将.scala源文件， 编译成class文件， 然后这些class文件被虚拟机加载并执行。
所以， 如果你对class文件格式和java虚拟机足够了解的话， 那么学习scala语言就会相对简单。Java文件编译成class文件， 而Scala源文件也是编译成class文件， 虽然他们语法大相径庭， 但是最后殊途同归。 如果我们能基于class文件分析scala的行为， 有助于理解scala语言。有人说scala的语法很多很难， 其实语法终归是写法， class文件的格式是不变的， 可以把scala的语法看成java语法的高级语法糖。
按照IT界的传统， 下面我们就从HelloWorld开始分析。 下面是scala版的HelloWorld源码：
object HelloWorld{
def main(args : Array[String]){
println("HelloWorld")
}
}
- 如果对scala的语法不是很熟悉， 并且对scala比较感兴趣， 建议先熟悉一下scala的基本语法。 这里简单说两以下几点：
以object关键字修饰一个类名， 这种语法叫做孤立对象，这个对象是单例的。 相当于将单例类和单例对象同时定义。 - 方法声明以def开头， 然后是方法名， 参数列表， 返回值， 等号， 方法体 。如下：
def doSomeThing(x : Int) : Int = {
x += 1
}
- 如果没有返回值， 可以省略等号， 直接写方法体。
Array[String]是scala的一种数据类型， 可以理解为字符串数组。
这篇博客的目的不是详细的讲解语法， 而是基于class文件来分析scala语法的实现方式， 所以对于语法只简单提一下 。
反编译scala HelloWorld
我们所说的反编译， 是指使用javap工具反编译class文件， 所以， 在反编译之前， 要先使用scalac编译器编译该源文件：
scalac HelloWorld.scala
命令执行完成后， 可以看到HelloWorld.scala所在的目录中多出两个class文件：
其中有一个是和HelloWorld.scala对应的HelloWorld.class 。 那么HelloWorld$.class是什么呢？难道一个scala类可以生成多个class吗? 下面通过反编译来找到答案。
首先反编译HelloWorld.class ：
javap -c -v -classpath . HelloWorld
反编译结果如下： （为了便于讲述， 给出了所有的输出， 会有些长）
Classfile /D:/Workspace/scala/scala-test/HelloWorld/HelloWorld.class
Last modified 2014-4-1; size 586 bytes
MD5 checksum 2ce2089f345445003ec6b4ef4ed4c6d1
Compiled from "HelloWorld.scala"
public final class HelloWorld
SourceFile: "HelloWorld.scala"
RuntimeVisibleAnnotations:
0: #6(#7=s#8)
ScalaSig: length = 0x3
05 00 00
minor version: 0
major version: 50
flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER
Constant pool:
#1 = Utf8 HelloWorld
#2 = Class #1 // HelloWorld
#3 = Utf8 java/lang/Object
#4 = Class #3 // java/lang/Object
#5 = Utf8 HelloWorld.scala
#6 = Utf8 Lscala/reflect/ScalaSignature;
#7 = Utf8 bytes
#8 = Utf8 :Q! !S3mY><vN7ea ...
#9 = Utf8 main
#10 = Utf8 ([Ljava/lang/String;)V
#11 = Utf8 HelloWorld$
#12 = Class #11 // HelloWorld$
#13 = Utf8 MODULE$
#14 = Utf8 LHelloWorld$;
#15 = NameAndType #13:#14 // MODULE$:LHelloWorld$;
#16 = Fieldref #12.#15 // HelloWorld$.MODULE$:LHelloWorld$;
#17 = NameAndType #9:#10 // main:([Ljava/lang/String;)V
#18 = Methodref #12.#17 // HelloWorld$.main:([Ljava/lang/String;)V
#19 = Utf8 Code
#20 = Utf8 SourceFile
#21 = Utf8 RuntimeVisibleAnnotations
#22 = Utf8 ScalaSig
{
public static void main(java.lang.String[]);
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #16 // Field HelloWorld$.MODULE$:LHelloWorld$;
3: aload_0
4: invokevirtual #18 // Method HelloWorld$.main:([Ljava/lang/String;)V
7: return
}
从输出结果可以看到， 这个类确实有传统意义上的main方法。
- 这个main方法中的字节码指令大概是这样：
getstatic访问一个静态字段， 这个静态字段是定义在HelloWorld$类中的MODULE$字段， 这个字段的类型是HelloWorld$ 。 讲到这里， 大概出现了单例的影子。 我们并没有定义这个类， 所以这个类是scala编译器自动生成的， 用来辅佐HelloWorld类。 - 然后使用这个静态对象调用main方法， 这个main方法是HelloWorld$类中的， 而不是当前HelloWorld中的。 它不是静态的， 而是成员方法。
下面反编译HelloWorld$类：
javap -c -v -classpath . HelloWorld$
反编译结果如下：
Classfile /D:/Workspace/scala/scala-test/HelloWorld/HelloWorld$.class
Last modified 2014-4-1; size 596 bytes
MD5 checksum 7b3e40952539579da28edc84f370ab9b
Compiled from "HelloWorld.scala"
public final class HelloWorld$
SourceFile: "HelloWorld.scala"
Scala: length = 0x0
minor version: 0
major version: 50
flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER
Constant pool:
#1 = Utf8 HelloWorld$
#2 = Class #1 // HelloWorld$
#3 = Utf8 java/lang/Object
#4 = Class #3 // java/lang/Object
#5 = Utf8 HelloWorld.scala
#6 = Utf8 MODULE$
#7 = Utf8 LHelloWorld$;
#8 = Utf8 <clinit>
#9 = Utf8 ()V
#10 = Utf8 <init>
#11 = NameAndType #10:#9 // "<init>":()V
#12 = Methodref #2.#11 // HelloWorld$."<init>":()V
#13 = Utf8 main
#14 = Utf8 ([Ljava/lang/String;)V
#15 = Utf8 scala/Predef$
#16 = Class #15 // scala/Predef$
#17 = Utf8 Lscala/Predef$;
#18 = NameAndType #6:#17 // MODULE$:Lscala/Predef$;
#19 = Fieldref #16.#18 // scala/Predef$.MODULE$:Lscala/Predef$;
#20 = Utf8 HelloWorld
#21 = String #20 // HelloWorld
#22 = Utf8 println
#23 = Utf8 (Ljava/lang/Object;)V
#24 = NameAndType #22:#23 // println:(Ljava/lang/Object;)V
#25 = Methodref #16.#24 // scala/Predef$.println:(Ljava/lang/Object;)V
#26 = Utf8 this
#27 = Utf8 args
#28 = Utf8 [Ljava/lang/String;
#29 = Methodref #4.#11 // java/lang/Object."<init>":()V
#30 = NameAndType #6:#7 // MODULE$:LHelloWorld$;
#31 = Fieldref #2.#30 // HelloWorld$.MODULE$:LHelloWorld$;
#32 = Utf8 Code
#33 = Utf8 LocalVariableTable
#34 = Utf8 LineNumberTable
#35 = Utf8 SourceFile
#36 = Utf8 Scala
{
public static final HelloWorld$ MODULE$;
flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
public static {};
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=0, args_size=0
0: new #2 // class HelloWorld$
3: invokespecial #12 // Method "<init>":()V
6: return
public void main(java.lang.String[]);
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: getstatic #19 // Field scala/Predef$.MODULE$:Lscala/Predef$;
3: ldc #21 // String HelloWorld
5: invokevirtual #25 // Method scala/Predef$.println:(Ljava/lang/Object;)V
8: return
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this LHelloWorld$;
0 9 1 args [Ljava/lang/String;
LineNumberTable:
line 5: 0
}
从输出结果可以知道:
HelloWorld$类有一个静态字段
public static final HelloWorld$ MODULE$; flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
它的访问修饰符是 public static final ， 类型是HelloWorld$ ， 字段名是 MODULE$ 。
HelloWorld$类还有一个静态初始化方法：
public static {};
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=1, locals=0, args_size=0
0: new #2 // class HelloWorld$
3: invokespecial #12 // Method "<init>":()V
6: return
在这个静态初始化方法中， 使用new指令创建了一个HelloWorld$对象， 并且调用该对象的构造方法<init>初始化这个对象。
实际上就是对静态字段MODULE$ 的赋值。
HelloWorld$类还有一个main方法：
public void main(java.lang.String[]);
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: getstatic #19 // Field scala/Predef$.MODULE$:Lscala/Predef$;
3: ldc #21 // String HelloWorld
5: invokevirtual #25 // Method scala/Predef$.println:(Ljava/lang/Object;)V
8: return
LocalVariableTable:
Start Length Slot Name Signature
0 9 0 this LHelloWorld$;
0 9 1 args [Ljava/lang/String;
LineNumberTable:
line 5: 0
- 这个main方法不是静态的， 是一个实例方法， 从它的字节码指令可以看出， 实现的是打印字符串HelloWorld的逻辑。
HelloWorld的实现方式总结
从上面的讲述中， 我们可知， scalac编译器使用两个class文件， 实现HelloWorld.scala源文件中的逻辑， 除了生成HelloWorld.class外， 还生产一个HelloWorld$.class 。实现逻辑如下： - 传统意义上的入口main方法被编译在HelloWorld.class中
在HelloWorld.class中的main方法中， 会访问HelloWorld$.class中的静态字段MODULE$ （这个字段的类型就是HelloWorld$） ， 并使用这个字段调用HelloWorld$中的main方法。
HelloWorld中的逻辑有点像下面这样（以下伪代码旨在说明原理， 并不符合java或scala的语法）：
public class HelloWorld{
public static void main(String[] args){
HelloWorld$.MODULE$.main(args);
}
}
3. 真正打印字符串“HelloWorld”的逻辑在HelloWorld$中。 这个类有一个main实例方法， 来处理打印字符串的逻辑， 并且该类中有一个HelloWorld$类型的静态字段MODULE$ 。 上面的HelloWorld类中的入口main方法， 正是通过这个字段调用的HelloWorld$的main实例方法来打印"HelloWorld" 。
HelloWorld$中的代码有点像这样（以下伪代码旨在说明原理， 并不符合java或scala的语法）：
public final class HelloWorld${
public static final HelloWorld$ MODULE$ = new HelloWorld$();
public void main(String[] args){
println("HelloWorld");
}
}
转自：http://blog.csdn.net/zhangjg_blog