学习Scala：伴生对象的实现原理

在上一篇关于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)
}

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

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

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

public final class Test$SourceFile: "Test.scala"Scala: length = 0x0minor version: 0major version: 50flags: ACC_PUBLIC, ACC_FINAL, ACC_SUPER{public static final Test$ MODULE$;flags: ACC_PUBLIC, ACC_STATIC, ACC_FINALprivate final java.lang.String a;flags: ACC_PRIVATE, ACC_FINALpublic static {};flags: ACC_PUBLIC, ACC_STATICCode:stack=1, locals=0, args_size=00: new           #2                  // class Test$3: invokespecial #12                 // Method "<init>":()V6: returnpublic java.lang.String a();flags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: getfield      #17                 // Field a:Ljava/lang/String;4: areturnpublic void printString();flags: ACC_PUBLICCode:stack=2, locals=1, args_size=10: getstatic     #24                 // Field scala/Predef$.MODULE$:Lscala/Predef$;3: aload_04: invokevirtual #26                 // Method a:()Ljava/lang/String;7: invokevirtual #30                 // Method scala/Predef$.println:(Ljava/lang/Object;)V10: returnprivate Test$();flags: ACC_PRIVATECode:stack=2, locals=1, args_size=10: aload_01: invokespecial #31                 // Method java/lang/Object."<init>":()V4: aload_05: putstatic     #33                 // Field MODULE$:LTest$;8: aload_09: ldc           #35                 // String a string11: putfield      #17                 // Field a:Ljava/lang/String;14: return
}

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

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

public class TestSourceFile: "Test.scala"RuntimeVisibleAnnotations:0: #6(#7=s#8)ScalaSig: length = 0x305 00 00minor version: 0major version: 50flags: ACC_PUBLIC, ACC_SUPER{private java.lang.String field;flags: ACC_PRIVATEpublic static void printString();flags: ACC_PUBLIC, ACC_STATICCode:stack=1, locals=0, args_size=00: getstatic     #16                 // Field Test$.MODULE$:LTest$;3: invokevirtual #18                 // Method Test$.printString:()V6: returnpublic static java.lang.String a();flags: ACC_PUBLIC, ACC_STATICCode:stack=1, locals=0, args_size=00: getstatic     #16                 // Field Test$.MODULE$:LTest$;3: invokevirtual #22                 // Method Test$.a:()Ljava/lang/String;6: areturnpublic java.lang.String field();flags: ACC_PUBLICCode:stack=1, locals=1, args_size=10: aload_01: getfield      #26                 // Field field:Ljava/lang/String;4: areturnpublic void field_$eq(java.lang.String);flags: ACC_PUBLICCode:stack=2, locals=2, args_size=20: aload_01: aload_12: putfield      #26                 // Field field:Ljava/lang/String;5: returnpublic void doSomeThing();flags: ACC_PUBLICCode:stack=2, locals=1, args_size=10: getstatic     #37                 // Field scala/Predef$.MODULE$:Lscala/Predef$;3: ldc           #39                 // String do something5: invokevirtual #43                 // Method scala/Predef$.println:(Ljava/lang/Object;)V8: returnpublic Test();flags: ACC_PUBLICCode:stack=2, locals=1, args_size=10: aload_01: invokespecial #46                 // Method java/lang/Object."<init>":()V4: aload_05: ldc           #47                 // String field7: 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 Testvar a1 = new Testprintln("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 Testval a = "a string"def printString = println(a)
}

下面进行验证：

object Main {def main(args : Array[String]){var a = Test.singlevar a1 = Test.single;println("a eq a1 : " + (a eq a1))}
}

打印结果为：

a eq a1 : true

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

学习Scala：伴生对象的实现原理相关推荐

学习Scala:伴生对象和伴生类之间的关系(二)
孤立对象是只有一个object关键字修饰的对象,该对象会编译成两个class文件,一个是以孤立对象的名字命名的class, 一个是以孤立对象的名字后面加上一个$ 字符命名的class, 这个class ...
四, Scala 伴生对象, 特质
文章目录四, Scala 伴生对象和伴生类 4.1 单例对象和伴生对象 4.1.1 什么是单例对象? 4.1.2 如何使用Scala的伴生对象和伴生类来实现单例模式? 4.1.2 apply方法 4 ...
scala 伴生对象的作用
1.什么是伴生对象 scala中的类不能定义静态成员,而代之以定义单例对象来替代单例对象通过object关键字来声明单例对象中的所有方法,可以直接通过object单例对象的名字直接来调用. 一个单 ...
kotlin学习之伴生对象（十五）
目录 1. 基本用法 2. 实现接口 3. 伴生对象扩展伴生对象最简单直白的理解就是与一个类相伴而生的对象,由于它处于类内部,所以必然和包含它的类存在某种联系. 1. 基本用法伴生对象使用关键字c ...
Scala学习教程笔记二之函数式编程、Object对象、伴生对象、继承、Trait、
1:Scala之函数式编程学习笔记: 1:Scala函数式编程学习:1.1:Scala定义一个简单的类,包含field以及方法,创建类的对象,并且调用其方法:class User {private v ...
Scala学习视频心得（一）语言特点、伴生对象
文章目录 1.Scala语言特点 2.伴生对象 1.Scala语言特点 Scala是一门以Java虚拟机(JVM)为运行环境并将面向对象和函数式编程的最佳特性结合在一起的静态类型编程语言(静态语言 ...
好程序员大数据学习路线分享scala单列和伴生对象
好程序员大数据学习路线分享scala单列和伴生对象 scala单例 object SingletonDemo { def main(args: Array[String]): Unit = { val ...
字节Scala面试题(2) --- 伴生对象
今天继续之前字节面试的另外一个问题 --- 伴生对象. ----------分界线:面试问题---------- 请描述一下,Scala中伴生对象编译成.class文件后与伴生类的关系. ------ ...
Scala中Object和Class区别(伴生类和伴生对象)
文章目录一,介绍二,类Class 2.1 类定义 2.2 构造器 1.基本语法 2.构造器参数 2.3 私有成员和Getter/Setter语法三,单例对象Object 四,伴生对象和伴生类介绍 ...

学习Scala：伴生对象的实现原理

学习Scala：伴生对象的实现原理相关推荐

最新文章

热门文章