Scala 伴生对象的实现原理

前言：这个面试出镜率很高，虽然咱们都会用，可是你有考虑过scala为什么这么设计么？你有考虑过大名鼎鼎的java23种设计模型，scala是怎么设计应用的么？

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

示例单例对象， 只不过为这个单例对象定义一个伴生类。 代码如下：

 class Test{
      var field = "field"
      def doSomeThing = println("do something")
    }
     
    object  Test {
        val a = "a string";
        def printString = println(a)
    }

 伴生类中有一个字段field和一个方法doSomething 。

编译这个文件， 同样生成两个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 "":()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."":()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."":()V
             4: aload_0
             5: ldc           #47                 // String field
             7: putfield      #26                 // Field field:Ljava/lang/String;
            10: return
    }

单例对象中的每个字段或方法，都对应Test类中的一个静态同名方法。 从上面的反编译结果得出， 这些静态方法仍然存在。 方法如下：

 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();

这些字段和方法是和伴生类中的字段和方法相对应的。 其中会为字段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修饰的单例对象）中信息的唯一性。

下面进行验证：

    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

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

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)
    }

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

    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

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