精华内容
下载资源
问答
  • Scala反编译

    千次阅读 2019-10-16 19:43:23
    Scala反编译 1)在项目的target目录Hello文件上点击右键->Show in Explorer->看到object底层生成Hello$.class和Hello.class两个文件 2)采用Java反编译工具jd-gui.exe反编译代码,将Hello.class拖到jd-gui....

    Scala反编译

    1)在项目的target目录Hello文件上点击右键->Show in Explorer->看到object底层生成Hello$.class和Hello.class两个文件

    在这里插入图片描述

    2)采用Java反编译工具jd-gui.exe反编译代码,将Hello.class拖到jd-gui.exe页面

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • object Hello { def main(args: Array[String]): Unit = { println("hello world") } }
  • 目录源码类`scala底层的编译机制`反编译class文件得到的demo01_test反编译class文件得到的demo01_test$反编译class文件得到的Worker 源码类 package com.xcu.chapter06 object demo01_test { // 源码 def main...

    • scala底层的编译机制

    在这里插入图片描述

    • 源码类
    package com.xcu.chapter06
    
    object demo01_test {
      def main(args: Array[String]): Unit = {
        var worker = new Worker
      }
    }
    
    class Worker{
      var name: String = _
      println("worker...")
    }
    
    • 反编译class文件得到的demo01_test
    package com.xcu.chapter06;
    
    import scala.reflect.ScalaSignature;
    
    @ScalaSignature(bytes="省略了二进制")
    public final class demo01_test
    {
      public static void main(String[] paramArrayOfString)
      {
        demo01_test$.MODULE$.main(paramArrayOfString);
      }
    }
    
    • 反编译class文件得到的demo01_test$
    package com.xcu.chapter06;
    
    public final class demo01_test$
    {
      public static final  MODULE$;
    
      static
      {
        new ();
      }
    
      public void main(String[] args)
      {
        Worker worker = new Worker();
      }
    
      private demo01_test$() {
        MODULE$ = this;
      }
    }
    
    • 反编译class文件得到的Worker
    package com.xcu.chapter06;
    
    import scala.reflect.ScalaSignature;
    
    @ScalaSignature(bytes="省略了二进制")
    public class Worker
    {
      private String name;
    	
      public String name() {return this.name; } 
      public void name_$eq(String x$1) { this.name = x$1; }
      public Worker() { Predef..MODULE$.println("worker..."); }
    }
    
    展开全文
  • **scala特质java反编译代码简单分析** 最近学习了scala特质的简单章节配合着视频进行了反编译分析。 1当trait只有抽象方法,没有非抽象方法时 package day07 object demo4 { def main(args: Array[String]): Unit...

    最近学习了scala特质的章节简单配合着视频进行了反编译分析。

    1当trait只有抽象方法,没有非抽象方法时

    package day07
    
    object demo4 {
      def main(args: Array[String]): Unit = {
        val person = new Student()
        person.say()
        person.run()
      }
    }
    trait Person{
      def say()
      def run()
    }
    class Student extends  Person {
      override def say(): Unit = {
        println("你好")
      }
    
      override def run(): Unit = {
        println("学生被罚跑步")
      }
    }
    

    java 底层很简单 生成了一个接口Person ,然后生成了Student继承了person 并实现了方法

    
    import scala.reflect.ScalaSignature;
    
    @ScalaSignature(bytes = "\006\001Q1q!\001\002\021\002G\005QA\001\004QKJ\034xN\034\006\002\007\005)A-Y=1o\r\0011C\001\001\007!\t9!\"D\001\t\025\005I\021!B:dC2\f\027BA\006\t\005\031\te.\037*fM\")Q\002\001D\001\035\005\0311/Y=\025\003=\001\"a\002\t\n\005EA!\001B+oSRDQa\005\001\007\0029\t1A];o\001")
    public interface Person {
      void say();
      
      void run();
    }
    
    
    package day07;
    
    import scala.Predef$;
    import scala.reflect.ScalaSignature;
    @ScalaSignature(bytes = "\006\001q1A!\001\002\001\013\t91\013^;eK:$(\"A\002\002\013\021\f\027\020M\034\004\001M\031\001A\002\007\021\005\035QQ\"\001\005\013\003%\tQa]2bY\006L!a\003\005\003\r\005s\027PU3g!\tia\"D\001\003\023\ty!A\001\004QKJ\034xN\034\005\006#\001!\tAE\001\007y%t\027\016\036 \025\003M\001\"!\004\001\t\013U\001A\021\t\f\002\007M\f\027\020F\001\030!\t9\001$\003\002\032\021\t!QK\\5u\021\025Y\002\001\"\021\027\003\r\021XO\034")
    public class Student
      implements Person
    {
      public void say() { Predef$.MODULE$.println("); }
    
    
      
      public void run() { Predef$.MODULE$.println("); }
    }
    
    

    如果有抽象方法和非抽象方法,继承类实现了抽象方法呢

    package day07
    
    object demo4 {
      def main(args: Array[String]): Unit = {
        val person = new Student()
        person.say()
        person.run()
      }
    }
    trait Person{
      def say()
      def run(): Unit ={
        println("老师跑步")
      }
    }
    class Student extends  Person {
      override def say(): Unit ={
        println("你好")
      }
      
    }
    

    java代码如下

    同样底层现有了个personl 接口

    package day07;
    
    import scala.reflect.ScalaSignature;
    
    @ScalaSignature(bytes = "\006\001Y1q!\001\002\021\002\007\005QA\001\004QKJ\034xN\034\006\002\007\005)A-Y=1o\r\0011C\001\001\007!\t9!\"D\001\t\025\005I\021!B:dC2\f\027BA\006\t\005\031\te.\037*fM\")Q\002\001C\001\035\0051A%\0338ji\022\"\022a\004\t\003\017AI!!\005\005\003\tUs\027\016\036\005\006'\0011\tAD\001\004g\006L\b\"B\013\001\t\003q\021a\001:v]\002")
    public interface Person {
      void say();
      
      void run();
    }
    
    

    接着是不同之处了,java底层生成了一个person$class抽象类并写下了一个同名run方法

    package day07;
    
    import scala.Predef$;
    
    public abstract class Person$class
    {
      public static void $init$(Person $this) {}
      
      public static void run(Person $this) { Predef$.MODULE$.println("老师跑步"); }
    }
    
    

    最后Student类实现了Person类重写了抽象方法,对于非抽象方法直接调用了抽象类的方法

    package day07;
    
    import scala.Predef$;
    import scala.reflect.ScalaSignature;
    
    @ScalaSignature(bytes = "\006\001i1A!\001\002\001\013\t91\013^;eK:$(\"A\002\002\013\021\f\027\020M\034\004\001M\031\001A\002\007\021\005\035QQ\"\001\005\013\003%\tQa]2bY\006L!a\003\005\003\r\005s\027PU3g!\tia\"D\001\003\023\ty!A\001\004QKJ\034xN\034\005\006#\001!\tAE\001\007y%t\027\016\036 \025\003M\001\"!\004\001\t\013U\001A\021\t\f\002\007M\f\027\020F\001\030!\t9\001$\003\002\032\021\t!QK\\5u\001")
    public class Student
      implements Person
    {
      public void run() { Person$class.run(this); } public Student() { Person$class.$init$(this); }
      
      public void say() { Predef$.MODULE$.println("你好"); }
    }
    
    

    最后如果抽象方法和非抽象方法都重写呢

    package day07
    
    object demo4 {
      def main(args: Array[String]): Unit = {
        val person = new Student()
        person.say()
        person.run()
      }
    }
    trait Person{
      def say()
      def run(): Unit ={
        println("老师跑步")
      }
    }
    class Student extends  Person {
      override def say(): Unit ={
        println("你好")
      }
     override def run(): Unit ={
        println("学生被罚跑步")
      }
    
    }
    

    直接看代码

    package day07;
    
    import scala.reflect.ScalaSignature;
    
    @ScalaSignature(bytes = "\006\001Y1q!\001\002\021\002\007\005QA\001\004QKJ\034xN\034\006\002\007\005)A-Y=1o\r\0011C\001\001\007!\t9!\"D\001\t\025\005I\021!B:dC2\f\027BA\006\t\005\031\te.\037*fM\")Q\002\001C\001\035\0051A%\0338ji\022\"\022a\004\t\003\017AI!!\005\005\003\tUs\027\016\036\005\006'\0011\tAD\001\004g\006L\b\"B\013\001\t\003q\021a\001:v]\002")
    public interface Person {
      void say();
      
      void run();
    }
    
    package day07;
    
    import scala.Predef$;
    
    public abstract class Person$class
    {
      public static void $init$(Person $this) {}
      
      public static void run(Person $this) { Predef$.MODULE$.println("老师跑步"); }
    }
    
    
    package day07;
    
    import scala.Predef$;
    import scala.reflect.ScalaSignature;
    
    @ScalaSignature(bytes = "\006\001q1A!\001\002\001\013\t91\013^;eK:$(\"A\002\002\013\021\f\027\020M\034\004\001M\031\001A\002\007\021\005\035QQ\"\001\005\013\003%\tQa]2bY\006L!a\003\005\003\r\005s\027PU3g!\tia\"D\001\003\023\ty!A\001\004QKJ\034xN\034\005\006#\001!\tAE\001\007y%t\027\016\036 \025\003M\001\"!\004\001\t\013U\001A\021\t\f\002\007M\f\027\020F\001\030!\t9\001$\003\002\032\021\t!QK\\5u\021\025Y\002\001\"\021\027\003\r\021XO\034")
    public class Student
      implements Person
    {
      public Student() { Person$class.$init$(this); }
      
      public void say() { Predef$.MODULE$.println("你好"); }
    
     
      public void run() { Predef$.MODULE$.println("学生被罚跑步"); }
    

    可以看出 student类继承了person类重写了say方法和run方法

    最后我们可以看出在scala中特质可以有抽象方法和非抽象方法,在java底层实际上是生成了一个interface和一个抽象类,如果继承类重写了抽象方法,则直接重写,如果重写了非抽象方法则直接从抽象类中调用那个静态的非抽象方法

    展开全文
  • Scala编译后的class文件反编译的结果

    千次阅读 2020-04-12 20:03:02
    class中变量的反编译结果 val 和 private val 修饰的成员变量被编译成 private final, 并提供getter var 和 private var 修饰的成员变量被编译成 private, 并提供getter和setter 没有修饰词修饰的和private[this]...
    1. class和object中参数的编译
    • class中变量的反编译结果
      val 和 private val 修饰的成员变量被编译成 private final, 并提供getter
      var 和 private var 修饰的成员变量被编译成 private, 并提供getter和setter
      没有修饰词修饰的和private[this]不会被编译成成员变量,但构造函数会带上
      class中非构造函数中的变量的被编译成获取这个变量的普通方法(感觉反编译有点问题?)
    • 伴生对象中的变量的反编译结果
      获取这个变量的静态方法(感觉应该是静态变量,不知道是不是反编译工具有点问题?)
    class Name(a: String,
               val b: String,
               var c: String,
               private var d: String,
               private val e: String,
               private[this] var f: String,
               private[this] val g: String) {
      val b01:String = "b01"
    }
    
    object Name {
      val a01: String = "a01"
    }
    
    // 反编译结果:
    public class Name {
      private final String b;
      private String c;
      private String d;
      private final String e;
      public String b() {  return this.b;}
      public Name(String a, String b, String c, String d, String e, String f, String g) {} 
      public String c() { return this.c; }
      public void c_$eq(String x$1) { this.c = x$1; } 
      private String d() {return this.d;}
      private void d_$eq(String x$1) { this.d = x$1; }
      private String e() { return this.e;}  
      public static String a01() {  return Name$.MODULE$.a01();}
      public String b01() {return this.b01; }
    }
    
    展开全文
  • 安装过程 1、安装JDK 1.8 2、在scala官网上下载windows免安装版本的scala进行解压安装 3、把scala的bin目录设置到环境变量当中 4、命令行输入 scala 查看是否安装成功 ...反编译工具的使用 直接点击打开jd-gui.e...
  • Scala 中Object 反编译Java 模拟运行 Scala 源代码 // Obj1.scala package com.abc.scala object Obj1 { def main(args: Array[String]): Unit = { println("I am here.") } def func(name:String): Unit = {...
  • 我们在学习scala的时候为了更好地理解scala,我们常常将scala编译过后的class文件进行反编译成java文件来更好地理解scala的独特与简洁之处,接下来我将利用反编译方法让大家更好地理解scala的构造方法的细节
  • 每一个scala object 相当于 java代码中的 同名静态类$下的一个静态对象 例如下面的TestScala object package com.atguigu.chapter01 //只要以后看到有 object TestScala ,你应该有这样一个认识 //1. object ...
  • 文章目录Scala的方法和函数有什么区别——反编译解析1. 方法-解析1.1 普通方法1.2 嵌套方法2. 函数-解析2.1 函数示例2.2 反编译结果2.3 函数反编译解析3. 为什么方法和函数可以相互转换?3.1 方法和函数混用示例3.2 ...
  • eq其实就是Java中的==,...通过反编译后清晰明了: // 用eq其实才是Java中的==,比较对象的内存地址 public void main(final String[] args) { String a = new String("abc"); String b = new String("abc"); .M..
  • javap一下,看反编译结果: package com.zxl.java.chapter01; //分析 // 1. object在底层会生成两个类Hello , Hello$ // 2. Hello中有个main函数,调用Hello$类的一个静态对象MODULES$ // 3. Hello$.MODULE$.对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,816
精华内容 2,326
关键字:

scala反编译后