学习Scala:孤立对象的实现原理
来源:互联网 发布:淘宝手办怎么验货拒签 编辑:程序博客网 时间:2024/05/19 01:31
在关于Scala的第一篇文章 学习Scala:从HelloWorld开始 中, 我们讲述了Scala的HelloWorld程序的执行原理。在Scala中,程序的入口使用孤立对象来实现, 在这篇博客中, 我们讲述了孤立对象是如何实现程序入口的, 不管Scala和Java的语法差别多大, 只要能以一定的方式实现标准的class文件入口类和入口函数, 就能被JVM执行。感兴趣的读者可以移步这篇博客。
在《Scala编程》这本书中, 把孤立对象和伴生对象都叫做单例对象。孤立对象指的是只有一个使用object关键字定义的对象, 伴生对象是指有一个使用object关键字定义的对象, 除此之外还有一个使用class关键字定义的同名类, 这个同名的类叫做伴生类。在Scala中单例对象这个概念多少都会让人迷惑, 按《Scala编程》这本书中的说法, 使用object关键字修饰的对象就叫做单例对象。其实这里的单例和设计模式中的单例模式的概念并不尽相同。在Scala中没有静态的概念, 所有的东西都是面向对象的。其实object单例对象只是对静态的一种封装而已, 在class文件层面中,object单例对象就是用静态(static)来实现的。在本博客中会对这个概念进行详细讲述。除此之外,在本文中还会涉及一重要的概念, 叫做虚构类(synthetic class) 。
关于孤立对象的实现原理, 学习Scala:从HelloWorld开始 这篇文章 已经讲解的差不多了, 本博客可以看做对上一篇博客的补充。
我们还是以简单的例子开始:
object Test {val a = "a string";def printString = println(a)}在这个孤立对象上, 定义了一个属性和一个方法。 在编译完成之后, 会看到有两个class文件
也就是说, 这个孤立对象也被编译成一个同名类Test 。 除此之外, 还有一个叫做Test$的类, 这个以$结尾的类就是所谓的虚构类(synthetic class, 《Scala编程》中将之翻译为虚构类) 。
下面使用javap反编译Test.class , 得到如下结果(去掉了常量池等信息):
public final class Test SourceFile: "Test.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{ public static void printString(); flags: ACC_PUBLIC, ACC_STATIC Code: stack=1, locals=0, args_size=0 0: getstatic #16 // Field Test$.MODULE$:LTest$; 3: invokevirtual #18 // Method Test$.printString:()V 6: return public static java.lang.String a(); flags: ACC_PUBLIC, ACC_STATIC Code: stack=1, locals=0, args_size=0 0: getstatic #16 // Field Test$.MODULE$:LTest$; 3: invokevirtual #22 // Method Test$.a:()Ljava/lang/String; 6: areturn}
由反编译的结果可以看出, 源码中的属性a对应一个静态的同名方法a(), 源码中的方法printString也对应一个静态的同名方法printString()。 静态方法a()调用Test$类中的静态字段MODULE$的a方法。 静态方法printString()调用Test$类中的静态字段MODULE$的printString方法。 如果用java来描述的话, Test类的逻辑是这样的:
public final class Test{public static java.lang.String a(){return Test$.MODULE$.a()}public static void printString(){Test$.MODULE$.printString()}}
下面再看Test类的虚构类Test$的javap反编译结果:
public final class Test$ SourceFile: "Test.scala" Scala: length = 0x0 minor version: 0 major version: 50 flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER{ public static final Test$ MODULE$; flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL private final java.lang.String a; flags: ACC_PRIVATE, ACC_FINAL public static {}; flags: ACC_PUBLIC, ACC_STATIC Code: stack=1, locals=0, args_size=0 0: new #2 // class Test$ 3: invokespecial #12 // Method "<init>":()V 6: return public java.lang.String a(); flags: ACC_PUBLIC Code: stack=1, locals=1, args_size=1 0: aload_0 1: getfield #17 // Field a:Ljava/lang/String; 4: areturn public void printString(); flags: ACC_PUBLIC Code: stack=2, locals=1, args_size=1 0: getstatic #24 // Field scala/Predef$.MODULE$:Lscala/Predef$; 3: aload_0 4: invokevirtual #26 // Method a:()Ljava/lang/String; 7: invokevirtual #30 // Method scala/Predef$.println:(Ljava/lang/Object;)V 10: return private Test$(); flags: ACC_PRIVATE Code: stack=2, locals=1, args_size=1 0: aload_0 1: invokespecial #31 // Method java/lang/Object."<init>":()V 4: aload_0 5: putstatic #33 // Field MODULE$:LTest$; 8: aload_0 9: ldc #35 // String a string 11: putfield #17 // Field a:Ljava/lang/String; 14: return}
首先看一下这个类里的内容。
public static final Test$ MODULE$; flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL
编译器在Test$中默认添加了静态初始化方法, 用于对静态字段MODULE$初始化:
public static {}; flags: ACC_PUBLIC, ACC_STATIC Code: stack=1, locals=0, args_size=0 0: new #2 // class Test$ 3: invokespecial #12 // Method "<init>":()V 6: return
源码中的字段a在Test$中对应一个非静态的字段a , 由于源码中的a是val的, 所以在Test$中对应的a字段是final的
private final java.lang.String a; flags: ACC_PRIVATE, ACC_FINAL
在Test$中还有一个成员方法a()与字段a对应, 这个方法的逻辑是返回a的值
public java.lang.String a(); flags: ACC_PUBLIC Code: stack=1, locals=1, args_size=1 0: aload_0 1: getfield #17 // Field a:Ljava/lang/String; 4: areturn
源码中的方法printString对应Test$中的printString方法。 这个方法的逻辑是调用方法a()获取字段a的值, 并打印a的值。
public void printString(); flags: ACC_PUBLIC Code: stack=2, locals=1, args_size=1 0: getstatic #24 // Field scala/Predef$.MODULE$:Lscala/Predef$; 3: aload_0 4: invokevirtual #26 // Method a:()Ljava/lang/String; 7: invokevirtual #30 // Method scala/Predef$.println:(Ljava/lang/Object;)V 10: return
private Test$(); flags: ACC_PRIVATE Code: stack=2, locals=1, args_size=1 0: aload_0 1: invokespecial #31 // Method java/lang/Object."<init>":()V 4: aload_0 5: putstatic #33 // Field MODULE$:LTest$; 8: aload_0 9: ldc #35 // String a string 11: putfield #17 // Field a:Ljava/lang/String; 14: return
如果用java代码描述的话,Test$的逻辑是这样的:
public final class Test${public static final Test$ MODULE$ = new Test$();private final String a = "a string"; public String a(){return a; } public void printString(){println(a()); } private Test$(){}}
所以, 在Scala里面称用object关键字修饰的对象是单例对象, 在实现的角度上看, 并不是十分确切。 虽然称之为对象, 但是编译器确实为他生成了一个类, 如上面例子中的object Test , 编译器确实生成了类Test。 但是这个类中只有静态方法, 即使是一个Scala中的字段, 也对应一个静态方法, 如上例中的字段a 。 这个类中的静态方法会访问虚构类Test$中的静态成员Test$ MODULE$ ,使用这个对象可以调用Test$中的其他成员方法,Test$中的成员和源码中的成员相对应, 只是会为源码中的字段添加同名方法。 主要的处理逻辑实际上是在虚构类Test$中完成的, Test类只是作为一个入口。
下面是看一下Scala是如何实现对单例对象的调用的。 首先写一个Scala的入口类:
object Main { //scala main def main(args : Array[String]){ Test.printString }}
相同的原理, 入口类Main也是单例对象, 实现原理和Test是相同的。 大部分的逻辑都在虚构类Main$中的成员方法main中实现的。反编译 Main$后的结果如下:
public final class Main$ SourceFile: "Main.scala" Scala: length = 0x0 minor version: 0 major version: 50 flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER{ public static final Main$ 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 Main$ 3: invokespecial #12 // Method "<init>":()V 6: return public void main(java.lang.String[]); flags: ACC_PUBLIC Code: stack=1, locals=2, args_size=2 0: getstatic #19 // Field Test$.MODULE$:LTest$; 3: invokevirtual #22 // Method Test$.printString:()V 6: return private Main$(); flags: ACC_PRIVATE Code: stack=1, locals=1, args_size=1 0: aload_0 1: invokespecial #26 // Method java/lang/Object."<init>":()V 4: aload_0 5: putstatic #28 // Field MODULE$:LMain$; 8: return}
用Java代码实现如下:
public final class Main${public static final Main$ MODULE$ = new Main$();public void main(String[] args){Test$.MODULE$.printString();} private Main$(){}}
由此可见, 在Main$中的成员方法main中, 直接调用了Test$.MODULE$.printString()方法, 而绕过了Test类, 这也是合理的, 因为只有Test$才处理相关逻辑。
而Main.class用java代码表示如下:
public final class Main{public static void main(String[] args){Main$.MODULE$.main(args);}}
做一下总结:
Main.class提供JVM的入口函数, 在入口函数中调用Main$的成员方法main, 而Main$的成员方法main又调用了Test$的成员方法printString来处理相关逻辑, 即打印字符串。
单例对象的调用方式如下图所示:
- 学习Scala:孤立对象的实现原理
- 学习Scala:孤立对象的实现原理
- scala中的孤立对象实现原理
- 学习Scala:伴生对象的实现原理
- Scala学习笔记-伴生对象于孤立对象
- scala中的伴生对象实现原理
- Scala学习(六)---Scala对象
- Scala类和对象的学习
- Scala面向对象学习
- scala 学习笔记--对象
- scala学习笔记-对象
- 【Scala】Scala的Predef对象
- 讲解孤立用户和对象名无效问题的解决方法
- scala学习五 继承的实现
- scala学习三:scala面向对象
- Scala 基础学习-Scala 单例对象
- Scala学习 2 Scala面向对象
- jQuery对象实现的原理
- android签名以及项目导出问题
- Linux内核及文件系统移植之jffs2烧录后无法启动
- typography
- Shell编程基础系列(1)------ls
- zedboard U盘挂载+交叉编译helloworld
- 学习Scala:孤立对象的实现原理
- 常用的android对话框
- Ubuntu 12.04 下Webmin的安装步骤
- UCGUI的移植
- Android中怎么去掉imgview 中上下的空白?
- UI控件----TextView 实例总结
- C语言库函数中的排序和查找函数
- C内存对齐规则
- 黑盒测试之等价类划分法