scala中的伴生对象实现原理

 孤立对象是只有一个object关键字修饰的对象。 该对象会编译成两个class文件， 一个是以孤立对象的名字命名的class，  一个是以孤立对象的名字后面加上一个$字符命名的class， 这个class又叫做虚构类。 源码中的孤立对象中的字段和方法， 都被编译成以孤立对象的名字命名的class中的静态方法， 这些静态方法都会访问单例的虚构类对象。 虚构了是传统意义上的单例模式， 并且在类初始化的时候有， 就会创建唯一的对象。 源码中的所有字段和方法都会在虚构类中有相对应的成员。 如果不明白的可以回过头去看一下上一篇博客， 博客的链接已经在上面给出了。 

本文主要分析伴生类和伴生对象的实现方法。 所谓伴生对象， 也是一个Scala中的单例对象， 使用object关键字修饰。 除此之外， 还有一个使用class关键字定义的同名类， 这个类和单例对象存在于同一个文件中， 这个类就叫做这个单例对象的伴生类， 相对来说， 这个单例对象叫做伴生类的伴生对象。 

为了延续上一篇文章， 在本文中的示例还会使用上一篇博客中的单例对象， 只不过为这个单例对象定义一个伴生类。 代码如下所示：

[java]  view plain  copy

 

1. class Test{  
2.   var field = "field"  
3.   def doSomeThing = println("do something")  
4. }  
5.   
6. object  Test {  
7.     val a = "a string";  
8.     def printString = println(a)  
9. }  

与上一篇博客相比， 这个示例程序多了一个伴生类。 伴生类中有一个字段field和一个方法doSomething 。 

编译这个文件， 同样生成两个class， 一个TEST.class和一个Test$.class 。 前文已经说过， 这个Test$.class叫做虚构类。

下面先反编译虚构类， 看看加入了伴生类之后， 编译出的虚构类是不是和上一篇博客中的相同。 下面是反编译结果。 （去掉了常量池等冗余的信息）

[java]  view plain  copy

 

1. public final class Test$  
2.   SourceFile: "Test.scala"  
3.     Scala: length = 0x0  
4.   minor version: 0  
5.   major version: 50  
6.   flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER  
7.   
8. {  
9.   public static final Test$ MODULE$;  
10.     flags: ACC_PUBLIC, ACC_STATIC, ACC_FINAL  
11.   
12.   
13.   private final java.lang.String a;  
14.     flags: ACC_PRIVATE, ACC_FINAL  
15.   
16.   
17.   public static {};  
18.     flags: ACC_PUBLIC, ACC_STATIC  
19.     Code:  
20.       stack=1, locals=0, args_size=0  
21.          0: new           #2                  // class Test$  
22.          3: invokespecial #12                 // Method "<init>":()V  
23.          6: return  
24.   
25.   public java.lang.String a();  
26.     flags: ACC_PUBLIC  
27.     Code:  
28.       stack=1, locals=1, args_size=1  
29.          0: aload_0  
30.          1: getfield      #17                 // Field a:Ljava/lang/String;  
31.          4: areturn  
32.   
33.   public void printString();  
34.     flags: ACC_PUBLIC  
35.     Code:  
36.       stack=2, locals=1, args_size=1  
37.          0: getstatic     #24                 // Field scala/Predef$.MODULE$:Lscala/Predef$;  
38.          3: aload_0  
39.          4: invokevirtual #26                 // Method a:()Ljava/lang/String;  
40.          7: invokevirtual #30                 // Method scala/Predef$.println:(Ljava/lang/Object;)V  
41.         10: return  
42.   
43.   private Test$();  
44.     flags: ACC_PRIVATE  
45.     Code:  
46.       stack=2, locals=1, args_size=1  
47.          0: aload_0  
48.          1: invokespecial #31                 // Method java/lang/Object."<init>":()V  
49.          4: aload_0  
50.          5: putstatic     #33                 // Field MODULE$:LTest$;  
51.          8: aload_0  
52.          9: ldc           #35                 // String a string  
53.         11: putfield      #17                 // Field a:Ljava/lang/String;  
54.         14: return  
55. }  

可以和上一篇博客中的对比一下， 发现虚构类没有任何变化， 源码中的单例对象中的字段和方法都在虚构类中有相应的对应字段和方法。 并且会为单例对象中的字段生成相应的方法。要说明的重点是：虽然在这个示例中加入了伴生类， 并且伴生类中也有字段和方法， 但是这个字段和方法并没有对应出现在虚构类中。 这也就说明， 虚构类中的信息只和单例对象有关， 单例对象的伴生类不会影响虚构类中的内容。 关于虚构类的实现细节， 可以参阅上一篇博客， 这里不再重复。 

下面反编译Test.class 。 反编译结果如下：

[java]  view plain  copy

 

1. public class Test  
2.   SourceFile: "Test.scala"  
3.   RuntimeVisibleAnnotations:  
4.     0: #6(#7=s#8)  
5.     ScalaSig: length = 0x3  
6.      05 00 00  
7.   minor version: 0  
8.   major version: 50  
9.   flags: ACC_PUBLIC, ACC_SUPER  
10.   
11. {  
12.   private java.lang.String field;  
13.     flags: ACC_PRIVATE  
14.   
15.   
16.   public static void printString();  
17.     flags: ACC_PUBLIC, ACC_STATIC  
18.     Code:  
19.       stack=1, locals=0, args_size=0  
20.          0: getstatic     #16                 // Field Test$.MODULE$:LTest$;  
21.          3: invokevirtual #18                 // Method Test$.printString:()V  
22.          6: return  
23.   
24.   public static java.lang.String a();  
25.     flags: ACC_PUBLIC, ACC_STATIC  
26.     Code:  
27.       stack=1, locals=0, args_size=0  
28.          0: getstatic     #16                 // Field Test$.MODULE$:LTest$;  
29.          3: invokevirtual #22                 // Method Test$.a:()Ljava/lang/String;  
30.          6: areturn  
31.   
32.   public java.lang.String field();  
33.     flags: ACC_PUBLIC  
34.     Code:  
35.       stack=1, locals=1, args_size=1  
36.          0: aload_0  
37.          1: getfield      #26                 // Field field:Ljava/lang/String;  
38.          4: areturn  
39.   
40.   public void field_$eq(java.lang.String);  
41.     flags: ACC_PUBLIC  
42.     Code:  
43.       stack=2, locals=2, args_size=2  
44.          0: aload_0  
45.          1: aload_1  
46.          2: putfield      #26                 // Field field:Ljava/lang/String;  
47.          5: return  
48.   
49.   public void doSomeThing();  
50.     flags: ACC_PUBLIC  
51.     Code:  
52.       stack=2, locals=1, args_size=1  
53.          0: getstatic     #37                 // Field scala/Predef$.MODULE$:Lscala/Predef$;  
54.          3: ldc           #39                 // String do something  
55.          5: invokevirtual #43                 // Method scala/Predef$.println:(Ljava/lang/Object;)V  
56.          8: return  
57.   
58.   public Test();  
59.     flags: ACC_PUBLIC  
60.     Code:  
61.       stack=2, locals=1, args_size=1  
62.          0: aload_0  
63.          1: invokespecial #46                 // Method java/lang/Object."<init>":()V  
64.          4: aload_0  
65.          5: ldc           #47                 // String field  
66.          7: putfield      #26                 // Field field:Ljava/lang/String;  
67.         10: return  
68. }  

在上一篇文章分析单例对象的时候说过， 单例对象中的每个字段或方法， 都对应Test类中的一个静态同名方法。 从上面的反编译结果可以看到， 这些静态方法仍然存在。 这些方法如下：

[java]  view plain  copy

 

1. public static void printString();  
2.   
3. public static java.lang.String a();  

这些静态方法的行为和上篇博客分析的是一样的。 这里不再重复。 

除了这两个静态方法之外， Test类中还存在一些其他字段和方法, 这些字段和方法都是成员方法， 而不是静态的。 这些字段和方法如下:

[java]  view plain  copy

 

1. private java.lang.String field;  
2.   
3. public java.lang.String field();  
4.   
5. public void field_$eq(java.lang.String);  
6.   
7. public void doSomeThing();  
8.   
9. public Test();  

这些字段和方法是和伴生类中的字段和方法相对应的。 其中会为字段field添加相关方法public java.lang.String field();和public void field_$eq(java.lang.String); 。 为字段添加同名getter方法和xxx_ $eq这样的setter方法， 是scalac编译器的默认行为， 这个问题在之前的博客  学习Scala：Scala中的字段和方法  中详细讲解过， 这里不再重复。

这里做一下总结：

1 伴生类中定义的字段和方法， 对应同类class类中的成员字段和成员方法；

2 伴生对象中定义的字段和方法， 对应同名类中的静态方法， 所以可以认为Scala中的object关键字是静态的另一种表示方式， 只是scala将这些静态的东西也封装成了对象；

3 伴生对象中定义的字段和方法， 对应虚构类中的成员字段和方法。 

4 同名类中的静态方法， 会访问单例的虚构类对象， 将相关的逻辑调用到虚构类中的成员方法中。 由于虚构类是单例的， 所以可以保证伴生对象中的字段都是唯一的。 也就是说虚构类的单例性， 保证了伴生对象（即scala中的object修饰的单例对象）中信息的唯一性。 

下面进行验证：

[java]  view plain  copy

 

1. object Main {  
2.   def main(args : Array[String]){  
3.     var a = Test.a;  
4.     var a1 = Test.a;  
5.     println("a eq a1 : " + (a eq a1))  
6.   }  
7. }  

上面的示例中， 访问了两次单例对象的a属性， 并且比较是否是同一个对象， 输出信息如下：

[java]  view plain  copy

 

1. a eq a1 : true  

5 伴生对象中的逻辑， 都转移到虚构类中去处理

6 伴生类中的逻辑， 都转移到同名类中的成员方法中去处理。 

7 需要注意，伴生类并不是单例的！！！ 它仍然可以创建多个对象， 只要在其他地方能够访问到这个伴生类。下面进行验证：

[java]  view plain  copy

 

1. object Main {  
2.   def main(args : Array[String]){  
3.     var a = new Test  
4.     var a1 = new Test  
5.     println("a eq a1 : " + (a eq a1))  
6.   }  
7. }  

打印结果为：

[java]  view plain  copy

 

1. a eq a1 : false  

创建的对象不是同一个对象， 所以Test伴生类不是单例的。 

8 如何在Scala中使用单例模式呢？我们上面说过， 单例对象中的属性都是永远唯一的， 所以将伴生类中的所有逻辑全部移到单例对象中， 去除伴生类， 让这个单例对象成为孤立对象， 这个孤立对象天然就是单例的。 以本例中的实例代码为例， 将伴生类和伴生对象合并到一起， 去除伴生类， 得到孤立对象如下：

[java]  view plain  copy

 

1. /*class Test{ 
2.   var field = "field" 
3.   def doSomeThing = println("do something") 
4. } 
5.  
6. object  Test { 
7.     val a = "a string"; 
8.     def printString = println(a) 
9. }*/  
10.   
11. object Test {  
12.   var field = "field"  
13.   def doSomeThing = println("do something")  
14.   
15.   val a = "a string";  
16.   def printString = println(a)  
17. }  

9 如果必须存在伴生类， 怎么保证伴生类是单例的呢？ 可以将伴生类的构造器私有， 并且在伴生对象中创建一个伴生类的对象， 这个对象就是唯一的。 代码如下所示：

[java]  view plain  copy

 

1. class Test private {  
2.   var field = "field"  
3.   def doSomeThing = println("do something")  
4. }  
5.   
6. object Test {  
7.   val single = new Test  
8.   val a = "a string"  
9.   def printString = println(a)  
10. }  

下面进行验证：

[java]  view plain  copy

 

1. object Main {  
2.   def main(args : Array[String]){  
3.     var a = Test.single  
4.     var a1 = Test.single;  
5.     println("a eq a1 : " + (a eq a1))  
6.   }  
7. }  

打印结果为：

[java]  view plain  copy

 

1. a eq a1 : true  

从输出结果可以知道， 两次访问Test.single得到的是同一个对象。 并且这个对象是唯一的， 在外部不能创建伴生类的对象， 因为它的构造器已经私有了， 所以他是单例的。