Scala方法和函数的本质区别——反编译解析

最新推荐文章于 2024-05-12 00:15:33 发布
最新推荐文章于 2024-05-12 00:15:33 发布
阅读量3.5k 收藏 3
点赞数 1
分类专栏： Scala 文章标签： Scala 方法和函数的区别 反编译 解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/alionsss/article/details/89323520
版权

文章目录

Scala方法和函数的本质区别——反编译解析

1. 方法-解析

1.1 普通方法

  1. 普通方法，即平常在class、object中定义的方法，示例如下
     object Demo01 {
 
  def sum1(a:Int, b: Int) : Int = a + b
  
  def main(args: Array[String]): Unit = {
    println(sum1(1, 2))
  }
  
}
  2. object中定义的方法和class中定义的方法稍有不同的是：object中的方法会多生成一个静态的方法
  3. 让我来看看上面代码的反编译结果：
  • Demo01.class
    import scala.reflect.ScalaSignature;
	
@ScalaSignature(bytes="\006\001U:Q!\001\002\t\002-\ta\001R3n_B\n$BA\002\005\003\tigM\003\002\006\r\005!A/Z:u\025\t9\001\"\001\003tW\026L(\"A\005\002\007\r|Wn\001\001\021\0051iQ\"\001\002\007\0139\021\001\022A\b\003\r\021+Wn\034\0312'\ti\001\003\005\002\022)5\t!CC\001\024\003\025\0318-\0317b\023\t)\"C\001\004B]f\024VM\032\005\006/5!\t\001G\001\007y%t\027\016\036 \025\003-AQAG\007\005\002m\tAa];ncQ\031AdH\021\021\005Ei\022B\001\020\023\005\rIe\016\036\005\006Ae\001\r\001H\001\002C\")!%\007a\0019\005\t!\rC\003%\033\021\005Q%\001\003nC&tGC\001\024*!\t\tr%\003\002)%\t!QK\\5u\021\025Q3\0051\001,\003\021\t'oZ:\021\007Eac&\003\002.%\t)\021I\035:bsB\021qF\r\b\003#AJ!!\r\n\002\rA\023X\rZ3g\023\t\031DG\001\004TiJLgn\032\006\003cI\001")
public final class Demo01 {
  public static void main(String[] paramArrayOfString) {
    Demo01..MODULE$.main(paramArrayOfString);
  }
  
  public static int sum1(int paramInt1, int paramInt2) {
    return Demo01..MODULE$.sum1(paramInt1, paramInt2);
  }
}
  • Demo01$.class
    import scala.Predef.;
import scala.runtime.BoxesRunTime;

public final class Demo01$ {
    
    public static final  MODULE$;

    static {
        new ();
    }

    public int sum1(int a, int b) {
        return a + b;
    }

    public void main(String[] args) {
        Predef..MODULE$.println(BoxesRunTime.boxToInteger(sum1(1, 2)));
    }

    private Demo01$() {
        MODULE$ = this;
    }
}
  1. Demo01.class是JVM真正调用的入口，由它再调用Demo01\$中的main。同时负责维护静态方法，经由此处的静态方法sum1调用Demo01\$中实际的方法sum1
  2. Demo01$.class负责维护实际使用的值、方法
  3. 可以看出Scala中的普通方法和Java中的方法区别不大，仅在object的静态编译处有细微区别

1.2 嵌套方法

  1. 嵌套方法，即定义在方法中的方法，示例如下
    object Demo01 {
	
  def main(args: Array[String]): Unit = {
    def sum2(a:Int, b: Int) : Int = a + b

    println(sum2(3, 4))
  }
	
}
  2. 嵌套方法也是方法，只是使用起来和普通方法的作用域不同，那么他们为什么会有不同的作用域呢？在本质上又有什么区别呢？
  3. 让我来看看上面代码的反编译结果：
  • Demo01.class
    import scala.reflect.ScalaSignature;

@ScalaSignature(bytes="\006\001-:Q!\001\002\t\002-\ta\001R3n_B\n$BA\002\005\003\tigM\003\002\006\r\005!A/Z:u\025\t9\001\"\001\003tW\026L(\"A\005\002\007\r|Wn\001\001\021\0051iQ\"\001\002\007\0139\021\001\022A\b\003\r\021+Wn\034\0312'\ti\001\003\005\002\022)5\t!CC\001\024\003\025\0318-\0317b\023\t)\"C\001\004B]f\024VM\032\005\006/5!\t\001G\001\007y%t\027\016\036 \025\003-AQAG\007\005\002m\tA!\\1j]R\021Ad\b\t\003#uI!A\b\n\003\tUs\027\016\036\005\006Ae\001\r!I\001\005CJ<7\017E\002\022E\021J!a\t\n\003\013\005\023(/Y=\021\005\025BcBA\t'\023\t9##\001\004Qe\026$WMZ\005\003S)\022aa\025;sS:<'BA\024\023\001")
public final class Demo01 {
  public static void main(String[] paramArrayOfString) {
    Demo01..MODULE$.main(paramArrayOfString);
  }
}
  • Demo01$.class
    import scala.Predef.;
import scala.runtime.BoxesRunTime;

public final class Demo01$ {
  public static final  MODULE$;
  
  private final int sum2$1(int a, int b) {
    return a + b;
  }
  
  public void main(String[] args) {
    Predef..MODULE$.println(BoxesRunTime.boxToInteger(sum2$1(3, 4)));
  }
  
  private Demo01$() {
    MODULE$ = this;
  }
  
  static {
    new ();
  }
}
  1. Demo01.class是JVM真正调用的入口，由它再调用Demo01\$中的main。其中不存在sum2的静态方法
  2. Demo01$.class负责维护实际使用的值、方法。其中存在sum2的方法，同时被更名为sum2$1
  3. 由此看来，嵌套方法其实利用了更名的方式，保证不与同名的普通方法冲突，在外部调用sum2其实调用的是class、object中的普通方法sum2，无法调用sum2$1，从而做到了限制作用域。实际上，从Java的角度上来看，嵌套方法还是一个普通方法。

2. 函数-解析

2.1 函数示例

object Demo01 {

  def main(args: Array[String]): Unit = {
    val max = (a: Int, b:Int) => if (a > b) a else b

    println(max(5, 6))
  }

}

2.2 反编译结果

  • Demo01.class
    import scala.reflect.ScalaSignature;

@ScalaSignature(bytes="\006\001-:Q!\001\002\t\002-\ta\001R3n_B\n$BA\002\005\003\tigM\003\002\006\r\005!A/Z:u\025\t9\001\"\001\003tW\026L(\"A\005\002\007\r|Wn\001\001\021\0051iQ\"\001\002\007\0139\021\001\022A\b\003\r\021+Wn\034\0312'\ti\001\003\005\002\022)5\t!CC\001\024\003\025\0318-\0317b\023\t)\"C\001\004B]f\024VM\032\005\006/5!\t\001G\001\007y%t\027\016\036 \025\003-AQAG\007\005\002m\tA!\\1j]R\021Ad\b\t\003#uI!A\b\n\003\tUs\027\016\036\005\006Ae\001\r!I\001\005CJ<7\017E\002\022E\021J!a\t\n\003\013\005\023(/Y=\021\005\025BcBA\t'\023\t9##\001\004Qe\026$WMZ\005\003S)\022aa\025;sS:<'BA\024\023\001")
public final class Demo01 {
  public static void main(String[] paramArrayOfString) {
    Demo01..MODULE$.main(paramArrayOfString);
  }
}
  • Demo01$.class
    import scala.Function2;
import scala.Predef.;
import scala.Serializable;
import scala.runtime.AbstractFunction2.mcIII.sp;
import scala.runtime.BoxesRunTime;

public final class Demo01$ {
  public static final  MODULE$;
  
  static {
    new ();
  }
  
  public void main(String[] args) {
    Function2 max = new AbstractFunction2.mcIII.sp() {
      public static final long serialVersionUID = 0L;
      
      public int apply$mcIII$sp(int a, int b) {
        return a > b ? a : b;
      }
      
      public final int apply(int a, int b) {
        return apply$mcIII$sp(a, b);
      }
    };
    Predef..MODULE$.println(BoxesRunTime.boxToInteger(max.apply$mcIII$sp(5, 6)));
  }
  
  private Demo01$() {
    MODULE$ = this;
  }
}

2.3 函数反编译解析

  1. Demo01.class，这个没什么好说的，和之前一样
  2. Demo01$.class中多出来一个类型为scala.Function2的max变量，其实它就是我们的函数。
  3. 查看scala源码可知scala.Function2是一个trait，同时对应的new AbstractFunction2是一个abstract class，这个class扩展了Function2。而函数对应的具体的功能其实是这个abstract class AbstractFunction2对trait Function2的方法apply的具体实现。
  4. 到这里，其实可以明白了，scala中的函数其实就是定义的一个trait，并且拥有一个对应的抽象实现类来实现具体的函数功能
  5. 扩展：
    • scala中的元组其实也是对应的类，类名为Tuple，最多拥有22个参数，即Tuple22。这里示例中max函数对应的的Function2其实指的就是可以传2个参数，同时源码中定义了可以传22个参数的函数，叫Function22
    • 如果比较熟悉Java8的话，我们可以看看lambda表达式，通常情况下这个lambda表达式也是传一个接口的匿名实现类，例如new Thread(() -> System.out.println("Hello World!")).start();。同时，Java8中定义了Function、Consumer、Supplier、Predicate几大接口用于Stream处理，正是和Scala函数相对应。
    • Scala中的trait经过反编译后，其实就是接口+抽象类。接口对应Java中的接口，抽象类用于实现trait自带的方法、变量等

3. 为什么方法和函数可以相互转换？

3.1 方法和函数混用示例

object Demo01 {

  def main(args: Array[String]): Unit = {
    // 一些单词
    val words= List("java", "scala", "python", "rust", "go", "c", "c++")
    
    // 定义转换字母大写的函数
    val toUpperFunc = (word: String) => word.toUpperCase()
    // 定义转换字母大写的方法
    def toUpperMethod(word: String): String = word.toUpperCase()
    
    // 方法和函数混用
    // map方法在源码中明确标注，需要的参数的类型是函数A => B
    words.map(toUpperFunc).foreach(println)
    words.map(toUpperMethod).foreach(println)
    // 结果一样
  }

}

看完上面的示例可能让人有点困惑。毕竟我们前面已经说了，方法和函数在本质上是两个不同的东西，那么方法为什么可以传进入参类型为函数的方法中呢？

3.2 方法与函数转换-解析

  1. 不急，让我们先看下面一个简单的示例（将方法转换为函数）
    object Demo01 {
  
  def sum2(a:Int, b: Int) : Int = a + b

  def main(args: Array[String]): Unit = {
    val func1: (Int, Int) => Int = sum2 _
    println(func1(9, 10))
    
// 你还可以写成如下形式
//    val func2: (Int, Int) => Int = sum2
//    println(func2(9, 10))
//
//    val func3 = sum2 _
//    println(func3(9, 10))
  }

}
  2. 让我来看看上面代码的反编译结果：
  • Demo01.class（省略）
  • Demo01$.class
    import scala.Function2;
import scala.Predef.;
import scala.Serializable;
import scala.runtime.AbstractFunction2.mcIII.sp;
import scala.runtime.BoxesRunTime;

public final class Demo01$ {
  public static final  MODULE$;
  
  static {
    new ();
  }
  
  public int sum2(int a, int b) {
    return a + b;
  }
  
  public void main(String[] args) {
    Function2 func1 = new AbstractFunction2.mcIII.sp() {
      public static final long serialVersionUID = 0L;
      
      public int apply$mcIII$sp(int a, int b) {
        return Demo01..MODULE$.sum2(a, b);
      }
      
      public final int apply(int a, int b) {
        return apply$mcIII$sp(a, b);
      }
    };
    Predef..MODULE$.println(BoxesRunTime.boxToInteger(func1.apply$mcIII$sp(9, 10)));
  }
  
  private Demo01$() {
    MODULE$ = this;
  }
}
  1. 函数的生成还是和前面的说明一样，实例化了一个实现了Function2的apply方法的抽象类AbstractFunction2对象。不过，注意，这里有一个微妙的区别，apply调用了apply\$mcIII\$sp方法，而apply\$mcIII\$sp方法又调用了sum2方法！！！没错，将方法转换为函数，其实函数并没有在内部重新实现该功能，而是直接调用了sum2方法！

3.3 混用示例-解析

  1. 现在准备好了，请看前面“单词转大写”的混用示例的反编译结果：
  • Demo01.class（省略）
  • Demo01$.class
    import scala.Function1;
import scala.Predef.;
import scala.Serializable;
import scala.collection.immutable.List;
import scala.collection.immutable.List.;
import scala.runtime.AbstractFunction1;
import scala.runtime.BoxedUnit;

public final class Demo01$ {
  public static final  MODULE$;
  
  public final String com$skey$test$mf$Demo01$$toUpperMethod$1(String word) {
    return word.toUpperCase();
  }
  
  public void main(String[] args) {
    List words = List..MODULE$.apply(Predef..MODULE$.wrapRefArray((Object[])new String[] { "java", "scala", "python", "rust", "go", "c", "c++" }));
    
    Function1 toUpperFunc = new AbstractFunction1() {
      public static final long serialVersionUID = 0L;
      
      public final String apply(String word) {
        return word.toUpperCase();
      }
    };
    ((List)words.map(toUpperFunc, List..MODULE$.canBuildFrom())).foreach(new AbstractFunction1() {
      public static final long serialVersionUID = 0L;
      
      public final void apply(Object x)
      {
        Predef..MODULE$.println(x);
      }
    });
    
    ((List)words.map(new AbstractFunction1()  {
      public static final long serialVersionUID = 0L;
      
      public final String apply(String word) {
        return Demo01..MODULE$.com$skey$test$mf$Demo01$$toUpperMethod$1(word);
      }
    }, List..MODULE$.canBuildFrom())).foreach(new AbstractFunction1() {
      public static final long serialVersionUID = 0L;
      
      public final void apply(Object x) {
        Predef..MODULE$.println(x);
      }
    });
  }
  
  private Demo01$() {
    MODULE$ = this;
  }
  
  static {
    new ();
  }
}
  1. 首先正常定义的函数部分和我们想象的一样，符合规则，向map中被传入了toUpperFunc函数，最终调用foreach进行了打印
  2. 而我们向map中传入toUpperMethod方法的部分，其实是实例化了一个匿名函数（这个函数的apply调用了toUpperMethod方法，即前面的"方法转换为函数"），将这个函数传入了map中，最终调用foreach进行了打印
  3. 这下，我们知道了，words数据的map确实只接收类型为A=>B的函数，向map传入方法没产生错误的原因是由于toUpperMethod方法被转换为了函数
  4. 总之，方法转换为函数，其实就是新生成一个函数，然后由该函数调用该方法！
蒋含竹
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SCALA环境搭建(3)_scala编译结果的反编译深入分析---大数据之_SCALA工作笔记006
添柴程序猿的专栏
04-09 487
然后我们来看一下,可以看到编译后的HelloScala.java出现了 HelloScala$.class HelloScala.class 我们知道,.java文件编译成了.class,而.scala也编译成了.class,那么我们用 scala HelloScala可以运行 那么我们用 java HelloScala可以看到执行报错了. 对吧可以看到执行的时候,他去找scala.Predef$这个类去了怎么回事呢 然后我们再去看,这个HelloScala是不能执行,我...
Scala—— 3.函数
01-07
在Scala中，方法和函数几乎可以等同(比如它们的定义、使用、运行机制都是一样的)，只是函数的使用方式更加的灵活多样。函数式编程是从编程方式(范式)的角度来谈的，可以这样理解：函数式编程把函数当作一等公民，...
Scala 面向对象（从反编译解释）
小王是个弟弟
09-12 653
从反编译角度解释scala面向对象的各种特性：属性、方法、构造器、封装、继承、多态、伴生类、伴生对象、抽象类、特质以及最具特色的动态混入和特质叠加
大数据Scala教程从入门到精通第六篇：Scala编译结果反编译分析
最新发布
七叔的博客
05-12 273
问题：为什么Scalac之后的生成的class文件有两个，一个带$的，一个不带$的？不能直接java 执行scala编译的字节码文件。直接运行的话就会报错，会报一个类没有被找到。引入类库就可以基于Java命令直接执行了。
函数的本质
weixin_33989058的博客
10-14 160
1.程序=数据+算法；C语言=数据+函数；模块化程序设计；2.面向过程是一种以过程为中心的编程思想3.首先将复杂的问题分解为一个个容易解决的问题4.分解过后的问题可以按照步骤一步步完成5.函数是面向过程在C语言中的体现6.解决问题的每个步骤可以用函数来实现7.程序中的声明可以理解为预先告诉编译器实体的存在，如：变量，函数，等等8.程序中的定义明确指示编译器实体的意义声明和定义...
6-4 函数的本质
成长的博客
10-19 204
6.4.1 C语言为什么会有函数 （1）整个程序分成多个文件（源文件），一个文件分成多个函数，一个函数分成多个语句，这就是整个程序的组织形式。这样组织的好处在于：分化问题、便于编写程序、便于分工。 （2）函数的出现是人（程序员和架构师）的需要，而不是机器（编译器、CPU）的需要。 （3）函数的目的就是实现模块化编程。说白了就是为了提供程序的可移植性。 6.4.2 函数书写的一般原则 第一，遵循一定格式；函数的返回类型、函数名、参数列表等。 第二，一个函数只做一件事；函数不能太长，也不宜太短。原则是一个函数只
Python133（函数01—明确学习目标）
weixin_42681308的博客
10-20 263
目标 函数的快速体验 函数的基本使用 函数的参数 函数的返回值 函数的嵌套使用 在模块中定义函数  
函数本质
s297165331的专栏
04-20 1109
栈是一种具有特殊的访问方式的存储空间（后进先出， Last In Out Firt，LIFO）SP(stack pointer)和FP寄存器sp寄存器在任意时刻会保存我们栈底的地址.fp寄存器也称为x29寄存器属于通用寄存器,但是在某些时刻我们利用它保存栈顶的地址!函数调用会开辟一段内存空间（栈空间）用于函数的局部变量、参数和寄存器的保护sub sp, sp,#0x20 ;拉伸...
Scala函数式编程专题--scala集合和函数
08-18
函数和方法的区别在于，方法是在类中定义的，而函数是可以单独存在的。 3. List 集合 List 集合是 Scala 中的一种常用数据结构，使用 apply 方法可以新建一个 List，例如：`val numbers = List(1, 2, 3, 4, 5, 1, 2...
Scala的函数和类
01-07
函数 函数声明 def 函数名(参数:参数类型...)[:返回值类型]{ //方法实现 } 标准函数 def sum(x:Int,y:Int):Int={ return x+y } 等价于 def sum(x:Int,y:Int)={ x+y } scala可以自动推断返回值类型，如果省略...
Scala—— 9.伴生对象apply方法
01-20
总结来说，Scala中的伴生对象和`apply`方法结合，提供了一种方便的、函数式的创建对象的方式。通过在伴生对象中定义`apply`方法，我们可以使类的实例化更加灵活，同时保持代码的简洁性。这对于构建模块化的、可扩展...
scala-sbt-scala编译工具
06-12
scala 编译工具 sbt 安装包。 Little or no configuration required for simple projects Scala-based build definition that can use the full flexibility of Scala code Accurate incremental recompilation using information extracted from the compiler Continuous compilation and testing with triggered execution Packages and publishes jars Generates documentation with scaladoc Supports mixed Scala/Java projects Supports testing with ScalaCheck, specs, and ScalaTest. JUnit is supported by a plugin. Starts the Scala REPL with project classes and dependencies on the classpath Modularization supported with sub-projects External project support (list a git repository as a dependency!) Parallel task execution, including parallel test execution Library management support: inline declarations, external Ivy or Maven configuration files, or manual management
ScalaShade:纠正阴影罐子中的@ScalaSignature批注
04-29
ScalaShade 在对类执行了阴影操作（重命名空间）后，可用于纠正在已编译的Scala类中找到的@ScalaSignature批注的类/ jar重写器。 Scala编译器在某些已编译的类中放置“ ScalaSignature”注释，以使其他运行时类型信息可用于Scala库，而这些信息通常无法在类文件中进行编码。 注释包含一个字符串，该字符串在解码时会产生类型信息。 此类型信息可以包含需要更新以反映着色操作以避免破坏Scala代码的名称空间。 如果您怀疑您可能遇到此问题，则可以通过运行“ scalap”（Scala正常发行版的一部分）并检查输出进行确认。 如果仍然存在对预着色名称空间的引用，则将需要对其进行更正。 当然，您也可以使用“ scalap”来确认ScalaShade已完成其工作。 例子 要更正一个罐子，请使用： java -jar scalashade.jar <inp
scala的偏函数
01-07
偏函数 偏函数可以提供了简洁的语法，可以简化函数的定义。配合集合的函数式编程，可以让代码更加优雅。 定义 偏函数被包在花括号内没有match的一组case语句是一个偏函数 偏函数是PartialFunction[A, B]的一个实例 A...
编译与反编译
海角12138的博客
10-20 1335
编译：高级语言转换成计算机认识的低级语言 编译的主要的目的是将便于人编写、阅读、维护的高级语言所写作的源代码程序，翻译为计算机能解读、运行的低级语言的程序，也就是可执行文件。 反编译：Java的反编译，一般是将class文件转换成java文件。 反编译：通过低级语言进行反向工程，获取其源代码 对python代码进行汇编： 如下所示： ...
理解函数的本质
ZiXiaweb的博客
08-09 431
函数的预编译 首先我们需要了解javaScript函数预编译过程: 1、创建AO对象（执行期上下文 ），寻找函数形参和变量声明。 2、把形参和变量名作为AO属性名，值为undefined。 3、把实参赋给形参，实参形参相统一。 4、寻找函数声明,赋值函数体。 5、函数开始执行。 代码实例 function fun(zhang){ console.log(zhang); var zhang = '小张'; consoloe.log(zhang); function zhang(){ret
编译和反编译
buct8527的博客
07-21 319
C# 反编译工具
函数/函数名的本质
ch_frank的博客
11-14 828
函数的本质是一段可执行性的代码，函数名则指向这段代码的首地址，函数名实际上就是一个存储可函数入口地址的常量，即func == &func；
scala中函数和方法的区别
05-20
在Scala中，函数和方法是有区别的。 方法是关联到对象上的，可以访问对象的状态和数据，方法可以被子类继承和重写。在Scala中定义方法时，使用def关键字。 函数是一种独立的代码块，可以接受一个或多个参数，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值