学习Scala：孤立对象的实现原理

最新推荐文章于 2022-03-03 17:59:51 发布
最新推荐文章于 2022-03-03 17:59:51 发布
阅读量296 收藏 1
点赞数
分类专栏： Scala

在关于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

 

}

 

 

首先看一下这个类里的内容。 

 

首先， 该类中有一个常量字段MODULE$， 它的类型就是当前的虚构类Test$ 。

  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

 

此外， 编译器在Test$中还加入默认的构造方法， 不过这个构造方法是私有的。 无法为外部调用。如下：

  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$(){}

}

 

由此可见， 这个虚构类Test$是单例的。 一方面， 这个类是编译器默认生成的，在Scala代码中无法访问到。 另一方面， Test$构造器私有了， 只在内部创建了一个对象赋给了静态引用MODULE$ 。 

 

所以， 在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来处理相关逻辑， 即打印字符串。 

 

单例对象的调用方式如下图所示：

吃鱼的羊
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
《大数据： Scala 原理介绍》
yexiangCSDN的专栏
12-21 408
一、Scala 原理介绍 （重点） =*=*=*=*= （从现在开始学习Scala 模式是对比Java来说，相当于复习一部分Java，对比着学习也更好的说明Scala的优点）=*=*=*=*= Java：定义类，然后在类中定义一个静态的main方法 scala：没有静态的概念，创建对象，在对象中定义main方法 1.Scala执行流程分析 2.Scala程序基本结构 （先了解） 完全面向对象: scala完全面向对象，故scala去掉了java中非面向对象的元素，如static关键...
Scala的一等公民和至简原则
最新发布
diskindom的博客
11-20 451
1. Scala 中，函数是一等公民具体体现在哪里 Scala 混合了面向对象特性和函数式的特性 函数可以作为值传递：函数可以作为参数传递给其他函数，也可以作为返回值返回给其他函数 函数可以赋值给变量：和其他数据类型⼀样，函数也可以赋值给变量，变量的类型就是函数的类型 函数可以嵌套定义：在函数内部可以定义另外⼀个函数，内部函数可以定义外部函数的变量 Scala支持匿名函数，可以直接定义并传递匿名函数 2. 说说 Scala 函数的至简原则 方法和函数不建议写 return 关键字，Scala 会使用函
Scala学习笔记-伴生对象于孤立对象
zhangdong_zender
05-11 1106
Scala-伴生对象于孤立对象
class 文件访问标志
实践求真知
08-03 386
一点睛 在常量池后，紧跟着访问标记。该标记使用两个字节表示，用于识别一些类或者接口层次的访问信息，包括：这个 Class 是类还是接口；是否定义为 public 类型；是否定义为 abstract 类型；如果是类的话，是否被声明为 final 等。各种访问标记如下所示： 标志名称 标志值 含义 ACC_PUBLIC 0x0001 标志为 public 类型 ACC_F.
第6章 类文件结构
往前的娘娘
07-26 1202
概述： 类文件就是二进制和源码的中介 其实java可以被编译成.class文件、JRuby，Groovy等都可以编译成.class文件，然后都java虚拟机上运行 1、Class类文件的结构 采用是8位字节为基础单位的二进制流，没有空隙，按顺序， Class 文件格式采用一种类似于C语言结构，分为无符号树和表。 无符号数属于基本的数据类型，以u1 u2、u4、u8来分别代表1个字节、2
Scala:在Scala中实现的所有算法
05-09
将算法实现添加为对象而不是类 添加有关算法实现和算法中存在功能的适当注释 在与您的算法相同的域下的test文件夹中添加一个测试规范。 没有测试规范的公关将不被接受 在测试规格中至少添加1个阳性和1个阴性测试 ...
learning-scala:用于学习 Scala
07-06
用于学习 Scala 如何使用 叉 克隆 执行sbt（前提是安装了JDK7或8） 苹果机/Linux $ cd learning-scala $ bin / sbt gen-idea 赢 $ cd learning-scala $ bin \ sbt.bat gen-idea
2048-Scala:Scala 中的 2048 实现
07-06
2048 在 Scala 中实现我为原来的 2048 游戏增加了 3 个难度级别（简单 | 中等 | 困难）在这里试试吧！ 请注意，这不是一个很好的 Scala 代码示例 :) 只是我在从丹佛会议返回的飞机上玩的东西。 我对它进行了大量调整...
chess-game-scala:用Scala编程语言简单实现象棋游戏
07-11
"chess-game-scala" 这个标题明确指出了我们要讨论的是一个使用Scala编程语言实现的象棋游戏项目。"scala" 是关键标签，表明这个项目是用Scala这一现代、函数式编程语言编写的。通过标题我们可以预见到，这个项目将...
scala：scala代码
02-10
在"scala: scala代码"的描述中，我们可以推测这是一个关于Scala编程语言的学习资源或者项目源代码。 1. **面向对象编程**：Scala是基于Java虚拟机（JVM）的语言，因此它兼容Java的所有类库。它支持类、对象和继承等...
JVM 字节码文件结构
xiangxiongfly
03-03 1081
Java源代码通过 javac 命令编译生产 .class 字节码文件。 使用javap命令查看字节码文件。如：javap -v Person.class 输出字节码信息，或 javap -v -p Person.class 输出完整字节码信息。 可以安装 jclasslib 插件查看。
第一部分 Scala 学习
pageniao的博客
05-23 800
第01章 Scala概述 1. Scala快速开发入门 Scala源文件以 “.scala" 为扩展名 ala程序的执行入口是main()函数 Scala语言严格区分大小写。 Scala方法由一条条语句构成，每个语句后不需要分号(Scala语言会在每行后自动加分号)，这也体现出Scala的简洁性。 如果在同一行有多条语句，除了最后一条语句不需要分号，其它语句需要分号(尽量一行就...
Scala学习笔记-初识函数式编程
JiajunBernoulli的博客
07-25 306
文章目录前言函数声明scala源码反编译后的java代码变量声明scala源码反编译后的ava代码函数引用scala源码反编译后的ava代码 前言 本文记录了初学Scala代码笔记以及反编译的java代码以供加深对scala代码运行过程的理解。 函数声明 scala源码 object ScalaFunction1 { def main(args:Array[String]):Unit={ ...
Scala学习笔记-快速了解基础语法
JiajunBernoulli的博客
07-25 284
文章目录基础语法标识符常用类型AnyAnyValAnyRefNothing算术操作符重载重载例子与方法的一些对比调用函数和方法 基础语法 标识符 scala源码 object ScalaLabel { def main(args: Array[String]): Unit = { //遵循java字母、数字、下划线，不能以数字开头 //scala标识符可以为字符 val...
Scala概述
PassionZheng的博客
04-27 440
Scala基础知识一.Scala运行原理Scala与Java 、JVM的关系语言特点环境搭建class和object说明伴生类与伴生对象所属类二.变量与数据类型 一.Scala运行原理 1.计算机语言发展过程 机器语言 汇编语言 高级语言 解释型语言(JavaScript) 要想运行多次，需要进行多次解释 支持跨平台 编译型语言(C\C++) 要想运行多次，不需要进行多次编译 不支持跨...
Scala运行原理机制图
qq_43151441的博客
04-08 951
说明：韩顺平粉丝。
Scala Parser原理介绍与源码分析
TJM2014的博客
04-02 519
Scala Parser原理介绍与源码分析 版权声明：本文为博主原创文章，未经博主允许不得转载。 手动码字不易，请大家尊重劳动成果，谢谢 作者：http://blog.csdn.net/wang_wbq 为了不耽误大家的时间，重要的事情说三遍： 本文不讲Scala Parser的用法！！ 本文不讲Scala Parse...
探索Scala：面向对象与函数式编程的集成语言
Scala是一款融合了面向对象和函数式编程理念的静态类型编程语言，其设计目标强调可扩展性。以下是文章的主要内容概要： 一、Scala简介 1.1 概念 Scala被命名为"Scalable Language"，意在适应开发者不断增长的需求。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值