精华内容
下载资源
问答
  • java编译查看字节码

    千次阅读 2014-04-01 22:42:38
    jdk中的bin里面自带有反编译的程序,叫javap.exe,利用他可以从编译生成的.class查看出对应的字节码代码 具体方法如下: 1.javap -verbose ** >> **.txt 例: 随便写个java类Person class Person{ String name;...

    深入理解字节码点击这里 

    jdk中的bin里面自带有反编译的程序,叫javap.exe,利用他可以从编译生成的.class查看出对应的字节码代码

    具体方法如下:

    1.javap -verbose ** >> **.txt

    例:

    随便写个java类Person

    class Person{
    	String name;	
    	char sex;
    	int age;
    	Person(){
    	}
    	Person(String name,char sex,int age){
    	this.name=name;
    	this.sex=sex;
    	this.age=age;	
    	}
    	String toString(int a){
    	return(String.valueOf(a));
    	}
    	String toString(char a){
    	return(String.valueOf(a));
    	}
    }

    编译生成.class后,放到桌面上,shift+右键在当前窗口打开命令行(win7可以,xp不行,就是去.class对应的目录输入命令)输入
    javap -verbose Person >> Person.txt
    然后在桌面上就看到了Person.txt

    内容:

    Classfile /C:/Users/linux_v/Desktop/Person.class
      Last modified Oct 11, 2012; size 589 bytes
      MD5 checksum 137de4fcce084d25ffb5c93b1708f63a
      Compiled from "Person.java"
    class Person
      SourceFile: "Person.java"
      minor version: 0
      major version: 51
      flags: ACC_SUPER
    
    Constant pool:
       #1 = Methodref          #8.#25         //  java/lang/Object."<init>":()V
       #2 = Fieldref           #7.#26         //  Person.name:Ljava/lang/String;
       #3 = Fieldref           #7.#27         //  Person.sex:C
       #4 = Fieldref           #7.#28         //  Person.age:I
       #5 = Methodref          #29.#30        //  java/lang/String.valueOf:(I)Ljava/lang/String;
       #6 = Methodref          #29.#31        //  java/lang/String.valueOf:(C)Ljava/lang/String;
       #7 = Class              #32            //  Person
       #8 = Class              #33            //  java/lang/Object
       #9 = Utf8               name
      #10 = Utf8               Ljava/lang/String;
      #11 = Utf8               sex
      #12 = Utf8               C
      #13 = Utf8               age
      #14 = Utf8               I
      #15 = Utf8               <init>
      #16 = Utf8               ()V
      #17 = Utf8               Code
      #18 = Utf8               LineNumberTable
      #19 = Utf8               (Ljava/lang/String;CI)V
      #20 = Utf8               toString
      #21 = Utf8               (I)Ljava/lang/String;
      #22 = Utf8               (C)Ljava/lang/String;
      #23 = Utf8               SourceFile
      #24 = Utf8               Person.java
      #25 = NameAndType        #15:#16        //  "<init>":()V
      #26 = NameAndType        #9:#10         //  name:Ljava/lang/String;
      #27 = NameAndType        #11:#12        //  sex:C
      #28 = NameAndType        #13:#14        //  age:I
      #29 = Class              #34            //  java/lang/String
      #30 = NameAndType        #35:#21        //  valueOf:(I)Ljava/lang/String;
      #31 = NameAndType        #35:#22        //  valueOf:(C)Ljava/lang/String;
      #32 = Utf8               Person
      #33 = Utf8               java/lang/Object
      #34 = Utf8               java/lang/String
      #35 = Utf8               valueOf
    {
      java.lang.String name;
        flags: 
    
    
      char sex;
        flags: 
    
    
      int age;
        flags: 
    
    
      Person();
        flags: 
    
        Code:
          stack=1, locals=1, args_size=1
             0: aload_0       
             1: invokespecial #1                  // Method java/lang/Object."<init>":()V
             4: return        
          LineNumberTable:
            line 5: 0
            line 6: 4
    
      Person(java.lang.String, char, int);
        flags: 
    
        Code:
          stack=2, locals=4, args_size=4
             0: aload_0       
             1: invokespecial #1                  // Method java/lang/Object."<init>":()V
             4: aload_0       
             5: aload_1       
             6: putfield      #2                  // Field name:Ljava/lang/String;
             9: aload_0       
            10: iload_2       
            11: putfield      #3                  // Field sex:C
            14: aload_0       
            15: iload_3       
            16: putfield      #4                  // Field age:I
            19: return        
          LineNumberTable:
            line 7: 0
            line 8: 4
            line 9: 9
            line 10: 14
            line 11: 19
    
      java.lang.String toString(int);
        flags: 
    
        Code:
          stack=1, locals=2, args_size=2
             0: iload_1       
             1: invokestatic  #5                  // Method java/lang/String.valueOf:(I)Ljava/lang/String;
             4: areturn       
          LineNumberTable:
            line 13: 0
    
      java.lang.String toString(char);
        flags: 
    
        Code:
          stack=1, locals=2, args_size=2
             0: iload_1       
             1: invokestatic  #6                  // Method java/lang/String.valueOf:(C)Ljava/lang/String;
             4: areturn       
          LineNumberTable:
            line 16: 0
    }
    
    看着挺高端的,有时间再慢慢研究,还有另一种命令

    2.javap –c ** >> **.txt

    上面链接给的测试类,我们确实时常讨论String,StringBuilder,StringBuffer之间的区别,其实看字节码确实能看出一点区别,即使不懂字节码。

    TestString.java

    public class TestString { 
        public String testString(String str1, String str2){ 
           return str1 + str2; 
        } 
        public String testStringBuffer(StringBuffer sb, String str){ 
           return sb.append(str).toString(); 
        }
        public String testStringBuilder(StringBuilder sb, String str){
    	return sb.append(str).toString();
        } 
    } 
    编译生成字节码后,输入
    javap -c TestString >> TestString.txt
    生成文本如下:

    Compiled from "TestString.java"
    public class TestString {
      public TestString();
        Code:
           0: aload_0       
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: return        
    
      public java.lang.String testString(java.lang.String, java.lang.String);
        Code:
           0: new           #2                  // class java/lang/StringBuilder
           3: dup           
           4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
           7: aload_1       
           8: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
          11: aload_2       
          12: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
          15: invokevirtual #5                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
          18: areturn       
    
      public java.lang.String testStringBuffer(java.lang.StringBuffer, java.lang.String);
        Code:
           0: aload_1       
           1: aload_2       
           2: invokevirtual #6                  // Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
           5: invokevirtual #7                  // Method java/lang/StringBuffer.toString:()Ljava/lang/String;
           8: areturn       
    }
    Compiled from "TestString.java"
    public class TestString {
      public TestString();
        Code:
           0: aload_0       
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: return        
    
      public java.lang.String testString(java.lang.String, java.lang.String);
        Code:
           0: new           #2                  // class java/lang/StringBuilder
           3: dup           
           4: invokespecial #3                  // Method java/lang/StringBuilder."<init>":()V
           7: aload_1       
           8: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
          11: aload_2       
          12: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
          15: invokevirtual #5                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
          18: areturn       
    
      public java.lang.String testStringBuffer(java.lang.StringBuffer, java.lang.String);
        Code:
           0: aload_1       
           1: aload_2       
           2: invokevirtual #6                  // Method java/lang/StringBuffer.append:(Ljava/lang/String;)Ljava/lang/StringBuffer;
           5: invokevirtual #7                  // Method java/lang/StringBuffer.toString:()Ljava/lang/String;
           8: areturn       
    
      public java.lang.String testStringBuilder(java.lang.StringBuilder, java.lang.String);
        Code:
           0: aload_1       
           1: aload_2       
           2: invokevirtual #4                  // Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;
           5: invokevirtual #5                  // Method java/lang/StringBuilder.toString:()Ljava/lang/String;
           8: areturn       
    }
    

    可以看到对于定义String类型的字符做字符连接时所执行的方法要多于StringBuffer和StringBuilder,StringBuffer和StringBuilder是一样的,不过StringBuilder是非线程安全的,StringBuffer是线程安全的,所以一般推荐使用StringBuffer,以前看人用java代码测试运行时间来观察执行效率,其实这样通过字节码大体猜测感觉也是挺不错的。


    展开全文
  • 一、新建HelloWorld.java文件,内容如下(简易): public class HelloWorld { public int firstStack() { int a = 100; int b = 100; int c = 100; return (a+b)*c; } } 二、将后缀名为java的...

    一、新建HelloWorld.java文件,内容如下(简易):

    public class HelloWorld {
    
        public int firstStack() {
            int a = 100;
            int b = 100;
            int c = 100;
            return (a+b)*c;
        }
    
    }
    

    二、将后缀名为java的源码文件编译成可被JVM可执行的二进制文件:
    找到你要反编译的java文件,cmd输入命令:

    javac HelloWorld.java
    

    然后敲回车。如下图:
    在这里插入图片描述
    用记事本打开编译后的class文件,会是一串看不懂的乱码:
    在这里插入图片描述

    三、反编译二进制文件文件:
    找到你要反编译的class文件,cmd输入命令:

    javap -c -verbose HelloWorld.class
    

    然后敲回车。如下图:
    在这里插入图片描述
    在反编译后的代码中,可以看到整个class文件执行的过程。

    四、Java字节码指令解释:
    Java字节码指令收集大全:https://www.cnblogs.com/longjee/p/8675771.html


























    注:以上内容仅提供参考和交流,请勿用于商业用途,如有侵权联系本人删除!


    持续更新中…

    如有对思路不清晰或有更好的解决思路,欢迎与本人交流,QQ群:273557553,个人微信:
    你遇到的问题是小编创作灵感的来源!


    展开全文
  • javap 反编译 java 字节码文件

    千次阅读 2019-11-13 19:17:57
    javap是 Java class文件分解器,可以反编译,也可以查看java编译器生成字节码,从而对代码内部的执行逻辑进行分析。 语法: 把java文件编译为class文件:javacTest.java(Test.javajava文件名) 生成对应的 ....

    概述:
             javap是 Java class文件分解器,可以反编译,也可以查看java编译器生成的字节码,从而对代码内部的执行逻辑进行分析。

    语法:
            把java文件编译为class文件:javac  Test.java  (Test.java为java文件名) 生成对应的 .class 文件 Test.class

            执行javap操作:javap 命令行 class文件名称(不加 .class后缀)

            例如: javap -c Test

    命令行
      -help 输出 javap 的帮助信息。
      -l 输出行及局部变量表。
      -b 确保与 JDK 1.1 javap 的向后兼容性。
      -public 只显示 public 类及成员。
      -protected 只显示 protected 和 public 类及成员。
      -package 只显示包、protected 和 public 类及成员。这是缺省设置。
      -private 显示所有类和成员。
      -J[flag] 直接将 flag 传给运行时系统。
      -s 输出内部类型签名。
      -c 输出类中各方法的未解析的代码,即构成 Java 字节码的指令。
      -verbose 输出堆栈大小、各方法的 locals 及 args 数,以及class文件的编译版本
      -classpath[路径] 指定 javap 用来查找类的路径。如果设置了该选项,则它将覆盖缺省值或 CLASSPATH 环境变量。目录用冒号分隔。
         - bootclasspath[路径] 指定加载自举类所用的路径。缺省情况下,自举类是实现核心 Java 平台的类,位于 jrelibt.jar 和 jrelibi18n.jar 中。
      -extdirs[dirs] 覆盖搜索安装方式扩展的位置。扩展的缺省位置是 jrelibext。
    示例:
    一个Demo.java文件(存放在桌面)

    class Demo 
    {
    	public static void main(String[] args) 
    	{
    		Integer aInteger = 56;
    		int aInt=0;
    		int aInt2 = 123;
    		String s="helloworld";
    		String aString = new String("IamString");
    	}
    }

    反汇编结果

    Compiled from "Demo.java"
    class Demo {
      Demo();
        Code:
           0: aload_0
           1: invokespecial #1                  // Method java/lang/Object."<init>":()V
           4: return
     
      public static void main(java.lang.String[]);
        Code:
           0: bipush        56
           2: invokestatic  #2                  // Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
           5: astore_1
           6: iconst_0
           7: istore_2
           8: bipush        123
          10: istore_3
          11: ldc           #3                  // String helloworld
          13: astore        4
          15: new           #4                  // class java/lang/String
          18: dup
          19: ldc           #5                  // String IamString
          21: invokespecial #6                  // Method java/lang/String."<init>":(Ljava/lang/String;)V
          24: astore        5
          26: return
    }

    对其中的语法不清楚啊?可以参照一下这两篇博客:

    javap -c 命令详解 http://blog.csdn.net/junsure2012/article/details/7099222

    JVM字节码之整型入栈指令(iconst、bipush、sipush、ldc) http://www.cnblogs.com/luyanliang/p/5498584.html

    如果还不清楚,放大招了:
    ORACLE 官方文档  Chapter 4. The class File Format  http://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html
     

    常用反编译工具:

    1、jd-gui:最好用,但有时反编译出来的结果会有遗漏。

            https://code.google.com/p/cxldemo/downloads/detail?name=jd-gui.exe&can=2&q

    2、DJ Java Decompiler:相对jd-gui易用性上差一些,但是反编译过来的结果更准确。

            http://www.neshkov.com/dj.html

    3、jclasslib bytecode viewer:将字节码转化为JVM指令的工具。

            http://sourceforge.net/projects/jclasslib/

    展开全文
  • 1,源码编译字节码 2,字节码编译成本地机器码(符合本地系统专属的指令) 解释执行也包括两种情况: 1,源码解释执行 2,字节码解释执行 解释和编译执行的区别是:是否产生中间本地机器码。 一、编译过程: 大...

    编译包括两种情况:
    1,源码编译成字节码
    2,字节码编译成本地机器码(符合本地系统专属的指令)
    解释执行也包括两种情况:
    1,源码解释执行
    2,字节码解释执行

    解释和编译执行的区别是:是否产生中间本地机器码。

    一、编译过程:

    大部分的程序代码从开始编译到最终转化成物理机的目标代码或虚拟机能执行的指令集之前,都会按照如下图所示的各个步骤进行:

    其中绿色的模块可以选择性实现。

    • 上图中间的那条分支是解释执行的过程(即一条字节码一条字节码地解释执行,如JavaScript),
    • 而下面的那条分支就是传统编译原理中从源代码到目标机器代码的生成过程。

    二、现代经典编译原理的思路:

    在执行前先对程序源码进行词法解析和语法解析处理,把源码转化为抽象语法树。

    对于一门具体语言的实现来说:

    • 词法和语法分析乃至后面的优化器和目标代码生成器都可以选择独立于执行引擎,形成一个完整意义的编译器去实现,这类代表是C/C++语言。
    • 也可以把抽象语法树或指令流之前的步骤实现一个半独立的编译器,这类代表是Java语言。
    • 又或者可以把这些步骤和执行引擎全部集中在一起实现,如大多数的JavaScript执行器。

    三、Javac编译

    在Java中提到“编译”,自然很容易想到Javac编译器将*.java文件编译成为*.class文件的过程,

    1,这里的Javac编译器称为前端编译器,其他的前端编译器还有诸如Eclipse JDT中的增量式编译器ECJ等。
    2,相对应的还有后端编译器,它在程序运行期间将字节码转变成机器码(现在的Java程序在运行时基本都是解释执行加编译执行),
       如HotSpot虚拟机自带的JIT(Just In Time Compiler)编译器(分Client端和Server端)。
    3,有时候还有静态提前编译器(AOT,Ahead Of Time Compiler)直接把*.java文件编译成本地机器代码,如GCJ、Excelsior JET等,这类编译器我们应该比较少遇到。
    

     Javac编译(前端编译)的过程:

    1,词法分析

    词法分析是将源代码的字符流转变为标记(Token)集合。

    单个字符是程序编写过程中的的最小元素,而标记则是编译过程的最小元素,关键字、变量名、字面量、运算符等都可以成为标记,
    比如整型标志int由三个字符构成,但是它只是一个标记,不可拆分。

     2、语法分析

    语法分析是根据Token序列来构造抽象语法树的过程。

    抽象语法树是一种用来描述程序代码语法结构的树形表示方式,语法树的每一个节点都代表着程序代码中的一个语法结构,如类型、修饰符、运算符等。

    经过这个步骤后,编译器就基本不会再对源码文件进行操作了,后续的操作都建立在抽象语法树之上。

    3、填充符号表

    完成了语法分析和词法分析之后,下一步就是填充符号表的过程。

    符号表是由一组符号地址和符号信息构成的表格。

    符号表中所登记的信息在编译的不同阶段都要用到,在语义分析(后面的步骤)中,符号表所登记的内容将用于语义检查和产生中间代码,在目标代码生成阶段,对符号名进行地址分配时,符号表是地址分配的依据。

    比如:默认构造器的添加。

    4、语义分析

    语法树能表示一个结构正确的源程序的抽象,但无法保证源程序是符合逻辑的。

    而语义分析的主要任务是:

    对结构上正确的源程序进行上下文有关性的审查。

     语义分析过程分为标注检查和数据及控制流分析两个步骤:

    1,标注检查的内容包括诸如:变量使用前是否已被声明、变量和赋值之间的数据类型是否匹配等。
    2,数据及控制流分析是对程序上下文逻辑更进一步的验证,检查出诸如:程序局部变量在使用前是否有赋值、方法的每条路径是否都有返回值、是否所有的受查异常都被正确处理了等问题。

    5、字节码生成 

    字节码生成阶段不仅仅是把前面各个步骤所生成的信息转化成字节码写到磁盘中,编译器还进行了少量的代码添加和转换工作。 

    • 实例构造器<init>()方法和类构造器<clinit>()方法就是在这个阶段添加到语法树之中的
    • 这里的实例构造器并不是指默认的构造函数,而是指我们自己重载的构造函数,

    如果用户代码中没有提供任何构造函数,那编译器会自动添加一个没有参数、访问权限与当前类一致的默认构造函数,这个工作在填充符号表阶段就已经完成了。

    四、JIT编译

    1、即时编译的产生:

    Java程序最初是仅仅通过解释器解释执行的,即对字节码逐条解释执行,这种方式的执行速度相对会比较慢,尤其当某个方法或代码块运行的特别频繁时,这种方式的执行效率就显得很低。

    于是后来在虚拟机中引入了JIT编译器(即时编译器),
    当虚拟机发现某个方法或代码块运行特别频繁时,就会把这些代码认定为“Hot Spot Code”(热点代码),
    为了提高热点代码的执行效率,在运行时,虚拟机将会把这些代码编译成与本地平台相关的机器码,并进行各层次的优化,完成这项任务的正是JIT编译器。

    PS:区别是:即时编译生成机器相关的中间码,可重复执行缓存效率高。解释执行直接执行字节码,重复执行需要重复解释。

    现在主流的商用虚拟机(如Sun HotSpot、IBM J9)中几乎都同时包含解释器和编译器

    (三大商用虚拟机之一的JRockit是个例外,它内部没有解释器,因此会有启动相应时间长,但它主要是面向服务端的应用,这类应用一般不会重点关注启动时间)。

    二者各有优势:

    • 当程序需要迅速启动和执行时,解释器可以首先发挥作用,省去编译的时间,立即执行;
    • 当程序运行后,随着时间的推移,编译器逐渐会失去作用,把越来越多的代码编译成本地代码后,可以获取更高的执行效率。

    解释执行可以节约内存,而编译执行可以提升效率。

    目前主流的HotSpot虚拟机中默认是采用解释器与其中一个编译器直接配合的方式工作。

    2、运行过程中会被即时编译器编译的“热点代码”有两类:

    被多次调用的方法。
    被多次调用的循环体。

    两种情况,编译器都是以整个方法作为编译对象,这种编译也是虚拟机中标准的编译方式。

    一段代码或方法是不是热点代码,是不是需要触发即时编译,需要进行Hot Spot Detection(热点探测)。

    3、目前主要的热点 判定方式有以下两种:

    3.1、基于采样的热点探测:

    虚拟机会周期性地检查各个线程的栈顶,如果发现某些方法经常出现在栈顶,那这段方法代码就是“热点代码”。
    • 好处是:实现简单高效,还可以很容易地获取方法调用关系,
    • 缺点是:很难精确地确认一个方法的热度,容易因为受到线程阻塞或别的外界因素的影响而扰乱热点探测。

    3.2、基于计数器的热点探测: 

    虚拟机会为每个方法,甚至是代码块建立计数器,统计方法的执行次数,
    如果执行次数超过一定的阀值,就认为它是“热点方法”。

    这种统计方法实现复杂一些,需要为每个方法建立并维护计数器,而且不能直接获取到方法的调用关系,但是它的统计结果相对更加精确严谨。

    4、在HotSpot虚拟机中使用的是第二种——基于计数器的热点探测方法两个计数器

    方法调用计数器和回边计数器。

    4.1、方法调用计数器:

    用来统计方法调用的次数,在默认设置下,方法调用计数器统计的并不是方法被调用的绝对次数,而是一个相对的执行频率,即一段时间内方法被调用的次数。

    4.2、回边计数器:

    用于统计一个方法中循环体代码执行的次数.
    (准确地说,应该是回边的次数,因为并非所有的循环都是回边),
    在字节码中遇到控制流向后跳转的指令就称为“回边”。

    在确定虚拟机运行参数的前提下,这两个计数器都有一个确定的阀值,当计数器的值超过了阀值,就会触发JIT编译。

    5、即时编译和解释执行的执行顺序:

    • 触发了JIT编译后,在默认设置下,执行引擎并不会同步等待编译请求完成,
    • 而是继续进入解释器按照解释方式执行字节码,直到提交的请求被编译器编译完成为止(编译工作在后台线程中进行)。
    • 当编译工作完成后,下一次调用该方法或代码时,就会使用已编译的版本。

    6、方法调用计数器触发即时编译的流程:

    方法计数器触发即时编译的过程与回边计数器触发即时编译的过程类似

    展开全文
  • javap反编译java字节码文件

    千次阅读 2016-08-16 14:58:17
     javap是 Java class文件分解器,可以反编译,也可以查看java编译器生成字节码,从而对代码内部的执行逻辑进行分析。 语法:  把java文件编译为class文件:javac Test.java (Test.javajava文件名) 生成对应...
  • 编译 什么是编译 编译方式 反编译 字节码 反汇编
  • 深入理解java编译后的字节码文件

    千次阅读 2018-04-19 17:15:53
    从我们写的java文件到通过编译器编译成java字节码文件(也就是.class文件),这个过程是java编译过程;而我们的java虚拟机执行的就是字节码文件。不论该字节码文件来自何方,由哪种编译器编译...
  • 我们把C代码编译java字节码,这样我们的C语言便具备了可跨品台属性。通过把C语言编译java字节码,我们不但能够继续学习和掌握编译原理相关的算法技术,于此同时,还能深入理解java虚拟机的基本原理,此乃...
  • javap 反编译Java class字节码

    万次阅读 2016-08-04 13:32:41
    javap是Java class文件分解器,可以反编译,也可以查看java编译器生成字节码。用于分解class文件。  javap.exe位于C:\Program Files\Java\jdk1.8.0_91\bin。由于在环境变量 -> Path 中设置了%JAVA_HOME%\bin的...
  • Java字节码和Dalvik字节码

    千次阅读 2017-06-17 00:03:37
    Java字节码和Dalvik字节码的区别,生成JAVA字节码和Dalvik字节码
  • 目录 idea生成java文档 idea反编译查看类的字节码文件 idea生成java文档 idea反编译查看类的字节码文件 配置好以后,使用
  •  ASM是一个java字节码操纵框架,它能被用来动态生成类或者增强既有类的功能。ASM 可以直接产生二进制 class 文件,也可以在类被加载入 Java 虚拟机之前动态改变类行为。Java class 被存储在严格格式定义的 .
  • 怎么用java自带反编译工具查看java字节码文件图文教程,用java自带反编译工具查看java字节码文件,首先,配置好java开发环境,环境变量各种配置,这里就不一一说了,相信大家都配置好了。下面入正题----怎么用java...
  • Java编译(三)Java即时编译(JIT编译): 运行时把Class文件字节码编译成本地机器码 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; 在《Java三种编译方式:前端编译 JIT编译 AOT编译》...
  • Java 动态生成二进制字节码

    千次阅读 2017-04-05 15:34:21
    Java动态代理过程中,会动态生成二进制字节码(只在内存中),该生成过程究竟是怎样的,我来一探究竟。 class字节码文件是根据JVM虚拟机规范中规定的字节码组织规则生成的。 1、类加载器 a.定义一个 Programmer类: ...
  • NodeJS生成字节码

    千次阅读 2020-01-18 21:37:13
    NodeJS生成字节码 相关问题: 1.nodejs源码保护 2.nodejs源码加密 3.nodejs提升运行速度 前言 传统的后端运行环境,如 Java、.NET,其源代码是经过编译才部署到服务器上运行的,不存在泄露的风险。而对于应用越来越...
  • java动态生成源文件和字节码方式

    千次阅读 2016-08-14 11:21:58
    ASM 是一个 Java 字节码操控框架。它能够以二进制形式修改已有类或者动态生成类。ASM 可以直接产生二进制 class 文件, 也可以在类被加载入 Java 虚拟机之前动态改变类行为。ASM 从类文件中读入信息后,能够改变类...
  • Java文件到字节码文件

    千次阅读 2017-08-07 14:53:27
    javac编译器将Java编译成为一个有效的字节码文件会经历4个步骤: 词法解析:将Java关键字排序,使得程序能有序运行。语法解析:词法解析后的Token序列整合为一颗抽象的语法树。语义解析:将抽象语
  • 下面详细了解JIT编译;从官方JDK中的HotSpot虚拟机的JIT编译器入手,先介绍解释器与JIT编译器是如何配合工作的,认识JIT编译器C1/C2;再看看JIT编译的是什么,以及触发条件是什么;...最后对比Java与C/C++的编译器。
  • 所谓动态编译,就是在程序运行时产生java类,并编译成class文件。 在D盘test目录下有两个java文件:AlTest1.java、AlTest2.java,现需要通过java代码实现java文件到class文件的编译操作: import java.io....
  • 关于Java字节码

    千次阅读 2018-09-24 10:25:23
    关于Java字节码 ...从写Java文件到编译字节码文件(也就是.class文件)的过程也就是Java文件编译的过程,我们所写的是Java文件而Java虚拟机编译的是字节码文件 class文件格式 ...
  • Java字节码

    千次阅读 2019-01-14 13:23:40
    Java最黑科技的玩法就是字节码编程,也就是动态修改或是动态生成 Java 字节码。使用字节码可以玩出很多高级的玩法,最高级的还是在 Java 程序运行时进行字节码修改和代码注入。听起来是不是一些很黑客,也很黑科技的...
  • Java字节码是Java源文件编译产生的中间文件java虚拟机是可运行java字节码的假想计算机 java的跨平台性也是相对与其他编程...再介绍java的编译过程先是java源程序扩展名为java的文件,由java编译程序将java字节码文件,
  • 保存java 动态代理生成字节码文件

    千次阅读 2019-03-29 14:03:31
    保存java 动态代理生成字节码文件 在Java中,常用的动态代理技术有JDK的动态代理和cglib动态代理,不管是什么动态代理,最后都要动态的生成对应的.class,正常情况下,这个字节码文件并不会保存到本地,只会存在于...
  • Java字节码增强探秘

    千次阅读 2019-09-10 14:03:58
    Java之所以可以“一次编译,到处运行”,一是因为JVM针对各种操作系统、平台都进行了定制,二是因为无论在什么平台,都可以编译生成固定格式的字节码(.class文件)供JVM使用。因此,也可以看出字节码对于Java生态的...
  • java-动态代理-jdk代理、cglib代理、生成字节码文件. 一、JDK动态代理和CGLIB字节码生成的区别?  * JDK动态代理只能对实现了接口的类生成代理,而不能针对类  * CGLIB是针对类实现代理,主要是对指定的类...
  • 首先编写一个java类 StringDemo1.java public class StringDemo1 { public static void main(String[] args) { String str1 = &amp;amp;amp;amp;quot;aaa&amp;amp;amp;amp;quot; + &amp;amp;amp;amp...
  • 本文介绍一种NodeJS源代码保护方式:通过把nodejs代码转化为字节码,用node启动字节码文件的方式,保护nodejs源代码不泄漏。可应用于nodejs项目提交源码、nodejs产品在不可信的环境中部署,防止别人获取源码。如同JS...
  • Java字节码文件

    千次阅读 2016-12-29 00:53:53
    编译器将Java源码编译成符合Java虚拟机规范的字节码文件。 字节码组成结构比较特殊,其内部不包含任何分隔符区分段落。 一组8位字节单位的字节流组成了一个完整的字节码文件。 字节码内部组成结构 《Java虚拟机规范 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 150,583
精华内容 60,233
热门标签
关键字:

java编译生成字节码

java 订阅