在上一篇关于Scala的文章 学习Scala：孤立对象的实现原理 中， 主要分析了孤立对象是如何实现的。 首先回顾一下。 孤立对象是只有一个object关键字修饰的对象。 该对象会编译成两个class文件， 一个是以孤立对象的名字命名的class， 一个是以孤立对象的名字后面加上一个$字符命名的class， 这个class又叫做虚构类。 源码中的孤立对象中的字段和方法， 都被编译成以孤立对象的名字命名的class中的静态方法， 这些静态方法都会访问单例的虚构类对象。 虚构了是传统意义上的单例模式， 并且在类初始化的时候有， 就会创建唯一的对象。 源码中的所有字段和方法都会在虚构类中有相对应的成员。 如果不明白的可以回过头去看一下上一篇博客， 博客的链接已经在上面给出了。
本文主要分析伴生类和伴生对象的实现方法。 所谓伴生对象， 也是一个Scala中的单例对象， 使用object关键字修饰。 除此之外， 还有一个使用class关键字定义的同名类， 这个类和单例对象存在于同一个文件中， 这个类就叫做这个单例对象的伴生类， 相对来说， 这个单例对象叫做伴生类的伴生对象。
为了延续上一篇文章， 在本文中的示例还会使用上一篇博客中的单例对象， 只不过为这个单例对象定义一个伴生类。 代码如下所示：
class Test{
var field = "field"
def doSomeThing = println("do something")
}
object Test {
val a = "a string";
def printString = println(a)
}
编译这个文件， 同样生成两个class， 一个TEST.class和一个Test$.class 。 前文已经说过， 这个Test$.class叫做虚构类。
下面先反编译虚构类， 看看加入了伴生类之后， 编译出的虚构类是不是和上一篇博客中的相同。 下面是反编译结果。 （去掉了常量池等冗余的信息）
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
}
下面反编译Test.class 。 反编译结果如下：
public 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_SUPER
{
private java.lang.String field;
flags: ACC_PRIVATE
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
public java.lang.String field();
flags: ACC_PUBLIC
Code:
stack=1, locals=1, args_size=1
0: aload_0
1: getfield #26 // Field field:Ljava/lang/String;
4: areturn
public void field_$eq(java.lang.String);
flags: ACC_PUBLIC
Code:
stack=2, locals=2, args_size=2
0: aload_0
1: aload_1
2: putfield #26 // Field field:Ljava/lang/String;
5: return
public void doSomeThing();
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: getstatic #37 // Field scala/Predef$.MODULE$:Lscala/Predef$;
3: ldc #39 // String do something
5: invokevirtual #43 // Method scala/Predef$.println:(Ljava/lang/Object;)V
8: return
public Test();
flags: ACC_PUBLIC
Code:
stack=2, locals=1, args_size=1
0: aload_0
1: invokespecial #46 // Method java/lang/Object."<init>":()V
4: aload_0
5: ldc #47 // String field
7: putfield #26 // Field field:Ljava/lang/String;
10: return
}public static void printString(); public static java.lang.String a();
除了这两个静态方法之外， Test类中还存在一些其他字段和方法, 这些字段和方法都是成员方法， 而不是静态的。 这些字段和方法如下:
private java.lang.String field; public java.lang.String field(); public void field_$eq(java.lang.String); public void doSomeThing(); public Test();
这里做一下总结：
1 伴生类中定义的字段和方法， 对应同类class类中的成员字段和成员方法；
2 伴生对象中定义的字段和方法， 对应同名类中的静态方法， 所以可以认为Scala中的object关键字是静态的另一种表示方式， 只是scala将这些静态的东西也封装成了对象；
3 伴生对象中定义的字段和方法， 对应虚构类中的成员字段和方法。
4 同名类中的静态方法， 会访问单例的虚构类对象， 将相关的逻辑调用到虚构类中的成员方法中。 由于虚构类是单例的， 所以可以保证伴生对象中的字段都是唯一的。 也就是说虚构类的单例性， 保证了伴生对象（即scala中的object修饰的单例对象）中信息的唯一性。
下面进行验证：
object Main {
def main(args : Array[String]){
var a = Test.a;
var a1 = Test.a;
println("a eq a1 : " + (a eq a1))
}
}上面的示例中， 访问了两次单例对象的a属性， 并且比较是否是同一个对象， 输出信息如下：
a eq a1 : true
5 伴生对象中的逻辑， 都转移到虚构类中去处理
6 伴生类中的逻辑， 都转移到同名类中的成员方法中去处理。
7 需要注意，伴生类并不是单例的！！！ 它仍然可以创建多个对象， 只要在其他地方能够访问到这个伴生类。下面进行验证：
object Main {
def main(args : Array[String]){
var a = new Test
var a1 = new Test
println("a eq a1 : " + (a eq a1))
}
}a eq a1 : false
8 如何在Scala中使用单例模式呢？我们上面说过， 单例对象中的属性都是永远唯一的， 所以将伴生类中的所有逻辑全部移到单例对象中， 去除伴生类， 让这个单例对象成为孤立对象， 这个孤立对象天然就是单例的。 以本例中的实例代码为例， 将伴生类和伴生对象合并到一起， 去除伴生类， 得到孤立对象如下：
/*class Test{
var field = "field"
def doSomeThing = println("do something")
}
object Test {
val a = "a string";
def printString = println(a)
}*/
object Test {
var field = "field"
def doSomeThing = println("do something")
val a = "a string";
def printString = println(a)
}class Test private {
var field = "field"
def doSomeThing = println("do something")
}
object Test {
val single = new Test
val a = "a string"
def printString = println(a)
}object Main {
def main(args : Array[String]){
var a = Test.single
var a1 = Test.single;
println("a eq a1 : " + (a eq a1))
}
}a eq a1 : true
学习Scala：伴生对象的实现原理,布布扣,bubuko.com
原文：http://blog.csdn.net/zhangjg_blog/article/details/23462695