Java基础从0开始---字节码指令

最新推荐文章于 2022-09-28 20:58:11 发布
最新推荐文章于 2022-09-28 20:58:11 发布
阅读量459 收藏
点赞数
分类专栏： Java 文章标签： java

Java-字节码指令

文章目录

　　字节码是JVM的机器语言。JVM加载类文件时，对类中的每个方法，都会得到一个字节码流。这些字节码流保存在JVM的方法区中。在程序运行过程中，当一个方法被调用时，它的字节码流就会被执行。

  • 基础简介
  1. 方法的字节码流就是JVM的指令（instruction）序列。
  2. Java虚拟机的指令：由一个字节长度、代表着某种特定操作含义的数字（操作码Opcode）以及跟随其后的0-n个代表此操作所需参数（操作数Operaands）而构成。即指令=操作码+操作数，虚拟机中许多指令并不包含操作数，只有一个操作码。
  3. JVM中，所有的计算都是围绕栈。因为JVM没有存储任意数值的寄存器，所有的操作数在计算开始之前，都必须先压入栈中。

源码如下：

package com.xxo.demo.util;
/**
 * Created by xiaoxiaomo on 2016/3/31.
 */
public class LineNumberDemo {
    private String c = "c" ;
    public static void main(String[] args) {
        String a = "abc" ;
        String b = "ab" ;
    }
}
  • 字节码和数据类型

在java虚拟机中，大多数的指令都包含了操作数所对应的数据类型。这一点很重要，理解了这一点很多指令都能联想记忆，例如：iload指令用于从局部变量表中加载int型的数据到操作数栈中，而fload就是加载float类型的数据。下面列出：

  1. i–int
  2. l–long
  3. s–short
  4. b–byte
  5. c–char
  6. f–float
  7. d–double
  8. a–reference

加载和存储指令

每个操作如果需要从操作栈中读参数，则总是将这些参数出栈，如果操作有结果，总是会将结果入栈。

加载：将数据从栈帧的局部变量表加载到操作数栈;
存储：将操作数栈存储到栈帧的局部变量表;

  • 1、将一个局部变量加载到操作栈-load。例如： iload、iload_n、lload、lload_n、fload、fload_n、dload、dload_n、aload、aload_n
  • 2、将一个数值从操作数栈存储到局部变量表-store。例如： istore、istore_n、lstore、lstore_n、fstore、fstore_n、dstore、dstore_n、astore、astore_n
  • 3、将一个常量加载到操作数栈。例如： bipush、sipush、ldc、ldc_w、ldc2_w、aconst_null、iconst_m1、iconst_i、lconst_l、fconst_f、dconst_d

例如，下面事例1：

package com.xxo.demo.util;

/**
 * Created by xiaoxiaomo on 2016/4/1.
 */
public class LoadStoreDemo {
    public static void main(String[] args) {
        int a = 128 ;//会自动拆箱为short
        int b = 22 ;//会自动拆箱为byte
        String c ="momo" ;
    }
}

通过javap -c编译后：

public class com.xxo.demo.util.LoadStoreDemo extends java.lang.Object{
public static java.lang.String a;

public com.xxo.demo.util.LoadStoreDemo();//默认构造方法
  Code:
   0:   aload_0 //一个引用类型的局部变量加载到操作栈
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V //
   4:   return  //没有返回值

public static void main(java.lang.String[]); //main方法
  Code:
   0:   sipush  128 //将一个short类型(int自动拆箱)常量加载到操作数栈（压入栈顶）
   3:   istore_1 //将数值从操作数栈存储到局部变量表，即a中(弹栈)
   4:   bipush  22 //将一个byte类型(自动拆箱)常量压入栈顶
   6:   istore_2 //将数值从操作数栈存储到局部变量表中，即b中
   7:   ldc     #2; //String momo //将字符串常量压入栈顶
   9:   astore_3 //将数值从操作数栈存储到局部变量表c中
   10:   return //没有返回值
}

运算指令

算术指令，用于对两个操作数栈上的值进行某种特定运算，并把结果重新存入到操作栈顶。
运算指令分为两种：整型（int,long）、浮点型（float,double）,对于没有直接支持 byte、short、char和boolean的算术指令使用int。

下面来看一下所有的算术指令：

  • 加法指令：iadd、ladd、fadd、dadd
  • 减法指令：isub、lsub、fsub、dsub
  • 乘法指令：imul、lmul、fmul、dmul
  • 除法指令：idiv、ldiv、fdiv、ddiv
  • 求余指令：irem、lrem、frem、drem
  • 取反指令：ineg、lneg、fneg、dneg
  • 位移指令：ishl、ishr、iushr、lshl、lshr、lushr
  • 按位或指令：ior、lor
  • 按位与指令：iand、land
  • 按位异或指令：ixor、lxor
  • 局部变量自增指令：iinc(是少见的直接更新一个局部变量而无需在操作数栈中进行读写的指令)
  • 比较指令：dcmpg、dcmpl、fcmpg、fcmpl、lcmp

java实例代码2：

/**
 * Created by xiaoxiaomo on 2016/4/1.
 */
public class OperatorDemo {

    public static void main(String[] args) {
        int a = 127 ;
        int b = 127000000 ;
        int d = a+b ;
        long c = a*b ;

    }
}

通过javap -c编译后：

    public class com.xxo.demo.util.OperatorDemo extends java.lang.Object{
    public com.xxo.demo.util.OperatorDemo();//默认构造方法
      Code:
       0:   aload_0
       1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
       4:   return

    public static void main(java.lang.String[]); //main方法
      Code:
       0:   bipush  127 //将一个常量加载到操作数栈
       2:   istore_1 //将常量从操作数栈存储到局部变量表中，即a中
       3:   ldc     #2; //int 127000000 //int类型
       5:   istore_2 //将数值从操作数栈存储到局部变量表
       6:   iload_1 //将一个局部变量a加载到操作栈
       7:   iload_2 //将一个局部变量b加载到操作栈
       8:   iadd //把上面两个操作栈中的int数据类型相加
       9:   istore_3 //把相加的结果d存到布局变量表
       10:  iload_1 //重复第6步操作
       11:  iload_2 //重复第7步操作
       12:  imul //相乘
       13:  i2l //int类型转为long类型
       14:  lstore  4 //把相乘的结果c存到布局变量表
       16:  return //没有返回值
    }

类型转换指令

类型转换指令，数据类型进行相互转换，一般用于实现用户代码的显式类型转换操作，或者用来处理 Java 虚拟机字节码指令集中指令非完全独立的问题。

宽化类型转换

  • int 类型到 long、float 或者 double 类型
  • long 类型到 float、double 类型
  • float 类型到 double 类型

窄化类型转换

i2b、i2c、i2s、l2i、f2i、f2l、d2i、d2l 和 d2f。窄化类型转换可能会导致转换结果产生不同的正负号、不同的数量级，转换过程很可能会导致数值丢失精度。

/**
 * 
 * Created by xiaoxiaomo on 2016/4/2.
 */
public class TypeCastDemo {

    public void typeCase(){
        int i = 128 ;
        short j = (short) i;
        double d = i*5.20 ;
        int z = (int) d;
    }
}
public class com.xxo.demo.util.TypeCastDemo extends java.lang.Object{
public com.xxo.demo.util.TypeCastDemo();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public void typeCase();//typeCase方法（下面简单的介绍一下）
  Code:
   0:   sipush  128 //将一个常量压入栈顶
   3:   istore_1 //将栈顶的值弹出（弹栈）存储到局部变量表中，i中
   4:   iload_1 //将局部变量中的i加载到操作栈
   5:   i2s //将i的int类型转为short
   6:   istore_2 //并存储到局布变量表中，j中
   7:   iload_1 //加载局部变量i，到操作栈
   8:   i2d //将操作栈变量i的类型转为double
   9:   ldc2_w  #2; //double 5.2d //
   12:  dmul //将操作栈中的值相乘
   13:  dstore_3 //将相乘的结果存储到局部变量表，d中
   14:  dload_3 //加载局部变量表中的d，到操作栈
   15:  d2i //将double类型的变量d转为int类型
   16:  istore  5 //把结果存储到局部变量表中，z中
   18:  return //没有返回值

}

对象创建与操作

虽然类实例和数组都是对象，但 Java 虚拟机对类实例和数组的创建与操作使用了不同的字节码指令：

创建类实例的指令：new
创建数组的指令：newarray，anewarray，multianewarray
访问类字段（static字段，或者称为类变量）和实例字段（非static字段，或者成为实例变量）的指令：getfield、putfield、getstatic、putstatic
把一个数组元素加载到操作数栈的指令：baload、caload、saload、iaload、laload、faload、daload、aaload
将一个操作数栈的值储存到数组元素中的指令：bastore、castore、sastore、iastore、fastore、dastore、aastore
取数组长度的指令：arraylength
检查类实例类型的指令：instanceof、checkcas

看看下面的实例：

/**
 * 对象创建与操作
 * Created by xiaoxiaomo on 2016/4/2.
 */
public class Instantiation {

    public static String NAME = "LIU BI" ;
    public static void main(String[] args) {
        int[] arr1 = new int[5] ;
        arr1[0] = 86 ;
        arr1[2] = 19 ;
        String[] strs = {"2","xiao","mo" , NAME } ;
        String tc = new String("abc") ;
    }
}

编译后

public class com.xxo.demo.util.Instantiation extends java.lang.Object{
public static java.lang.String NAME;

public com.xxo.demo.util.Instantiation();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public static void main(java.lang.String[]); //main方法
  Code:
   0:   iconst_5 //将常量5压入栈顶
   1:   newarray int //创建一个int类型的数组
   3:   astore_1 //将数组存储到局部变量表中，arr1中
   4:   aload_1 //将局部变量arr1加载到操作栈
   5:   iconst_0 //将常量0加载到操作数栈，
   6:   bipush  86 //将一个byte类型常量86加载到操作数栈
   8:   iastore //将一个操作数栈的值86储存到数组元素中,arr[0]中
   9:   aload_1 //将局部变量arr1加载到操作栈
   10:  iconst_2 //将常量2加载到操作数栈
   11:  bipush  19 //将一个byte类型常量19加载到操作数栈
   13:  iastore //将一个操作数栈的值19储存到数组元素中,arr[2]中
   14:  iconst_4 // 将常量4压入栈顶
   15:  anewarray       #2; //class java/lang/String //创建一个String类型的数组
   18:  dup //直接操作操作数栈
   19:  iconst_0 //将常量0加载到操作数栈，
   20:  ldc     #3; //String 2 //字符串常量加载到操作数栈,2
   22:  aastore //将引用类型的操作数栈的值储存到数组元素中，strs[0]中
   23:  dup //直接操作操作数栈
   24:  iconst_1 //将常量1加载到操作数栈，
   25:  ldc     #4; //String xiao //字符串常量xiao加载到操作数栈
   27:  aastore //将引用类型的操作数栈的值储存到数组元素中，strs[1]中
   28:  dup //直接操作操作数栈
   29:  iconst_2 //将常量2加载到操作数栈，
   30:  ldc     #5; //String mo //字符串常量加载到操作数栈
   32:  aastore //将引用类型的操作数栈的值储存到数组元素中，strs[2]中
   33:  dup  //直接操作操作数栈
   34:  iconst_3 //将常量3加载到操作数栈，
   35:  getstatic       #6; //Field NAME:Ljava/lang/String; //获取静态变量
   38:  aastore //将引用类型的操作数栈的值储存到变量中
   39:  astore_2 //将引用类型的操作数栈的值储存到变量中
   40:  new     #2; //class java/lang/String //实例化一个对象
   43:  dup //直接操作操作数栈
   44:  ldc     #7; //String abc //将字符串常量abc加载到操作数栈
   46:  invokespecial   #8; //Method java/lang/String."<init>":(Ljava/lang/String;)V //调用实例方法new String
   49:  astore_3 //将引用类型的操作数栈的值储存到变量中，tc中
   50:  return //没有返回值

static {}; //静态区域
  Code:
   0:   ldc     #9; //String LIU BI //字符串常量‘LIU BI’加载到操作数栈
   2:   putstatic       #6; //Field NAME:Ljava/lang/String;//实例静态字段
   5:   return //没有返回值
}

操作数栈管理指令

虚拟机提供了一些用于直接操作操作数栈的指令，包括：pop、pop2、dup、dup2、dup_x1、dup2_x1、dup_x2、dup2_x2 和 swap。如上事例，直接操作数栈


控制转移指令

控制转移指令，可以让JVM有条件或无条件地从指定指令转移到指令的下一条指令继续执行程序。控制转移指令包括有：

条件分支：ifeq、iflt、ifle、ifne、ifgt、ifge、ifnull、ifnonnull、if_icmpeq、if_icmpne、if_icmplt, if_icmpgt、if_icmple、if_icmpge、if_acmpeq 和 if_acmpne
复合条件分支：tableswitch、lookupswitch
无条件分支：goto、goto_w、jsr、jsr_w、ret

  • 事例代码
package com.xxo.demo.util;

/**
 * 流程控制语句
 * Created by xiaoxiaomo on 2016/4/2.
 */
public class ControlStatement {

    public int max(int a , int b) {
        int max = a ;
        if( b > a ){
            max = b ;
        }
        return max ;
    }

    public static void formatPrint( int[] arr ){
        System.out.print("[");
        for (int i = 0 ; i < arr.length ; i++ ){
            System.out.print(arr[i]);

            if( i < arr.length -1 ){
                System.out.print(",");
            }
        }
        System.out.print("]");
    }
}

反编译后字节码如下：

public class com.xxo.demo.util.ControlStatement extends java.lang.Object{
public com.xxo.demo.util.ControlStatement();
  Code:
   0:   aload_0
   1:   invokespecial   #1; //Method java/lang/Object."<init>":()V
   4:   return

public int max(int, int); //max方法
  Code:
   0:   iload_1 //将一个局部变量加载到操作数栈，a
   1:   istore_3 //将上面操作数栈存储到局部变量表中，max
   2:   iload_2 //将变量压入操作数栈中，b
   3:   iload_1 //将变量压入操作数栈中，a
   4:   if_icmple 9 //比较栈顶的两个值的大小,如果为false回调到第9条字节码处执行
   7:   iload_2 //如果判断为true,会加载栈顶的值，b
   8:   istore_3 //将b值存储到局部变量max中
   9:   iload_3 //如果判断为false，则会加载局部变量数值，max
   10:  ireturn //返回一个int类型数据

public static void formatPrint(int[]);//一个静态方法
  Code:
   0:   getstatic  #2; //Field java/lang/System.out:Ljava/io/PrintStream;//获取输出流
   3:   ldc     #3; //String [ //将字符串常量‘[’压入栈顶(和加载到操作数栈一个意思)
   5:   invokevirtual #4; //Method java/io/PrintStream.print:(Ljava/lang/String;)V //io输出流
   8:   iconst_0 //将常量0加载到操作数栈
   9:   istore_1 //将栈顶的值出栈存储到局部变量表中，i=0
   10:  iload_1 //加载局部变量i到操作栈，此时i已有值
   11:  aload_0 //加载引用类型的变量到操作栈中，arr
   12:  arraylength //获取数组长度，arr.length
   13:  if_icmpge 47 //判断局部变量i是否大于等于数组长度，如果true，跳到47条指令
   16:  getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;//获取输出流
   19:  aload_0 //加载引用类型的变量到操作栈中,arr；同第11条指令
   20:  iload_1 //加载int类型的变量到操作栈中,即i
   21:  iaload //把arr的数组元素加载到操作数栈中
   22:  invokevirtual   #5; //Method java/io/PrintStream.print:(I)V //调用输出打印
   25:  iload_1 //加载局部变量i到操作栈
   26:  aload_0 //加载引用类型的变量到操作栈中,arr；同第11条指令
   27:  arraylength 获取数组长度，arr.length；同第12条指令
   28:  iconst_1 //将常量1加载到操作数栈，
   29:  isub //在操作数栈中使用数组长度减去变量1
   30:  if_icmpge 41 //如果变量i大于等于数组长度，跳转到第41条指令
   33:  getstatic #2; //Field java/lang/System.out:Ljava/io/PrintStream;//获取输出流
   36:  ldc     #6; //String , //将字符串常量‘,’压入栈顶
   38:  invokevirtual   #4; //Method java/io/PrintStream.print:(Ljava/lang/String;)V调用输出打印
   41:  iinc    1, 1 //变量i自增1（局部变量表中的第1个位置的值（即i）加1）
   44:  goto    10 //回调到第10条指令，继续执行
   47:  getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;//获取输出流
   50:  ldc     #7; //String ] //将字符串常量‘]’压入栈顶
   52:  invokevirtual   #4; //Method java/io/PrintStream.print:(Ljava/lang/String;)V调用输出打印
   55:  return //没有返回值
}

方法调用和返回指令


  • 四条指令用于方法调用

invokevirtual：指令用于调用对象的实例方法，根据对象的实际类型进行分派（虚方法分派），这也是Java语言中最常见的方法分派方式。
invokeinterface：指令用于调用接口方法，它会在运行时搜索一个实现了这个接口方法的对象，找出适合的方法进行调用。
invokespecial：指令用于调用一些需要特殊处理的实例方法，包括实例初始化方法、私有方法和父类方法。
invokestatic：指令用于调用类方法（static方法）。

  • 方法返回指令

ireturn：（当返回值是 boolean、byte、char、short 和 int 类型时使用）
lreturn：返回long类型
freturn：返回floalt类型
dreturn：返回double类型
areturn：返回对象
return ：指令表示为void的方法、实例初始化方法、类和接口的类初始化方法使用。

抛出异常

在程序中显式抛出异常的操作会由 athrow 指令实现，除了这种情况，还有别的异常会在其它 Java 虚拟机指令检测到异常状况时由虚拟机自动抛出。


同步

JVM可以支持方法级的同步和方法内部一段指令序列的同步，这两种同步结构都是使用管程（Monitor）来支持的。

  • 方法级的同步：是隐式，即无需通过字节码指令来控制的，它实现在方法调用和返回操作之中。

虚拟机可以从方法常量池中的方法表结构（method_info Structure）中的 ACC_SYNCHRONIZED 访问标志区分一个方法是否同步方法。当方法调用时，调用指令将会检查方法的 ACC_SYNCHRONIZED 访问标志是否被设置，如果设置了，执行线程将先持有管程，然后再执行方法，最后再方法完成（无论是正常完成还是非正常完成）时释放管程。在方法执行期间，执行线程持有了管程，其他任何线程都无法再获得同一个管程。如果一个同步方法执行期间抛出了异常，并且在方法内部无法处理此异常，那这个同步方法所持有的管程将在异常抛到同步方法之外时自动释放。

  • 同步一段指令集序列：通常是由Java语言中的synchronized块来表示的。

JVM的指令集中有monitorenter和monitorexit两条指令来支持synchronized关键字的语义，正确实现 synchronized 关键字需要编译器与 Java 虚拟机两者协作支持。

结构化锁定（Structured Locking）：是指在方法调用期间每一个管程退出都与前面的管程进入相匹配的情形。因为无法保证所有提交给 Java 虚拟机执行的代码都满足结构化锁定，所以 Java 虚拟机允许（但不强制要求）通过以下两条规则来保证结构化锁定成立。假设 T 代表一条线程，M 代表一个管程的话：

T在方法执行时持有管程 M 的次数必须与 T 在方法完成（包括正常和非正常完成）时释放管程 M 的次数相等。
找方法调用过程中，任何时刻都不会出现线程 T 释放管程 M 的次数比 T 持有管程 M 次数多的情况。
请注意，在同步方法调用时自动持有和释放管程的过程也被认为是在方法调用期间发生。

/**
 * Created by xiaoxiaomo on 2016/4/2.
 */
public class SynDemo {

    Integer num=0;
    private Lock lock=new ReentrantLock();
    private AtomicInteger number=new AtomicInteger(0);

    public static void main(String[] args) {
        new SynDemo().syn() ;
    }

    private void syn() {
        //启动10个线程
        for (int i = 0; i < 10; i++) {
            new Thread(new TestSyn()).start() ;
            //new Thread(new LockTest()).start() ;
            //new Thread(new LockFreeTest()).start() ;
        }
    }

    class TestSyn implements Runnable{

        @Override
        public void run() {
            synchronized (num) {  // 间接的被转化为单线程了，相当于串行执行代码
                if(  num < 5 ){
                    System.out.println(String.format(
                            "name:%s,   num:%s",Thread.currentThread().getName(),num));
                    num ++ ;
                }
                System.out.println(num);
            }
        }
    }

    /**
     * 使用lock方式
     */
    class LockTest implements Runnable{

        @Override
        public void run() {

            lock.lock();
            if (num < 5) {
                System.out.println(String.format("thread:%s   num:%s Do some thing", Thread.currentThread().getName(), num));
                num++;

            }
            lock.unlock();
        }
    }

    /**
     * 使用原子类
     */
    class LockFreeTest implements Runnable{

        @Override
        public void run() {

            if (number.get() < 5) {
                System.out.println(String.format("thread:%s   num:%s Do some thing", Thread.currentThread().getName(),
                        number.getAndIncrement()));
                //num++;
                // System.out.println(num);

            }
        }
    }
}

编译后，如下：

public class com.xxo.demo.util.SynDemo extends java.lang.Object{
java.lang.Integer num;

public com.xxo.demo.util.SynDemo();
  Code:
   0:   aload_0
   1:   invokespecial   #3; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   iconst_0
   6:   invokestatic    #4; //Method java/lang/Integer.valueOf:(I)Ljava/lang/Integer;
   9:   putfield        #5; //Field num:Ljava/lang/Integer;
   12:  aload_0
   13:  new     #6; //class java/util/concurrent/locks/ReentrantLock
   16:  dup
   17:  invokespecial   #7; //Method java/util/concurrent/locks/ReentrantLock."<init>":()V
   20:  putfield        #2; //Field lock:Ljava/util/concurrent/locks/Lock;
   23:  aload_0
   24:  new     #8; //class java/util/concurrent/atomic/AtomicInteger
   27:  dup
   28:  iconst_0
   29:  invokespecial   #9; //Method java/util/concurrent/atomic/AtomicInteger."<init>":(I)V
   32:  putfield        #1; //Field number:Ljava/util/concurrent/atomic/AtomicInteger;
   35:  return

public static void main(java.lang.String[]);
  Code:
   0:   new     #10; //class com/xxo/demo/util/SynDemo
   3:   dup
   4:   invokespecial   #11; //Method "<init>":()V
   7:   invokespecial   #12; //Method syn:()V
   10:  return

static java.util.concurrent.locks.Lock access$000(com.xxo.demo.util.SynDemo);
  Code:
   0:   aload_0
   1:   getfield        #2; //Field lock:Ljava/util/concurrent/locks/Lock;
   4:   areturn

static java.util.concurrent.atomic.AtomicInteger access$100(com.xxo.demo.util.SynDemo);
  Code:
   0:   aload_0
   1:   getfield        #1; //Field number:Ljava/util/concurrent/atomic/AtomicInteger;
   4:   areturn
}



1.除非注明，博文均为原创，转载请标明地址： http://blog.xiaoxiaomo.com/2016/04/01/Java-字节码指令/
2.文章作者： 小小默
3.发布时间：2016年04月01日 - 09时07分

karaage
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java字节码指令集的使用详细
09-05
本篇文章对Java字节码指令集的使用进行了详细的介绍。需要的朋友参考下
JVM 中篇（3）：字节码指令集
Mr_tianyanxiaobai的博客
07-14 330
字节码指令集概述执行模型字节码与数据类型指令分类1.加载与存储指令常用指令再谈操作数栈与局部变量表局部变量压栈指令2.1. 局部变量压栈指令局部变量压栈常用指令集常量入栈指令 概述 执行模型 如果不考虑异常处理的话，那么Java虚拟机的解释器可以使用下面这个伪代码当做最基本的执行模型来理解 do{ 自动计算PC寄存器的值加1; 根据PC寄存器的指示位置，从字节码流中取出操作码; if(字节码存在操作数) 从字节码流中取出操作数; 执行操作码所定义的操作; }while(字节码
c语言中0，‘0’，‘\0’的区别
热门推荐
modi000的博客
01-16 1万+
1、0 整数类型，占4个字节 2、‘0’ 用单引号括起来的是字符类型，ASCII 码值为48，占一个字节 3、‘\0’ 用单引号括起来是字符类型，前面有\，即使转义字符，ASCII 码值为0，占一个字节 所以：0与‘\0’虽所占字节数不同，但数值上是相等的，所以在初始化字符数组的时候，会用0来初始化。 例如： char ch[6]; memset(ch,0,sizeof(ch));...
CAN通信矩阵的理解（CAN报文信号的属性）
a1428685070的博客
09-28 5024
1）信号的高位（most significant bit），即最能表达信号特性的因子。比如转速2000rpm，0x7D0，即011111010000b。最左侧的位，数量级最大，牵一发动全身，即高位2）信号的低位（least significant bit），即最不能表达信号特性的因子。刚才转速中，最右侧的0，即低位。3）信号的起始位其实就是信号的最低位。主机厂在定义整车CAN总线通信矩阵时，每一个信号都从其最低位开始填写。
java操作字节码_使用javap分析Java字节码的一个例子
weixin_39738416的博客
02-12 85
I have the following source code in Java:class Outer {Nested nested;Nested getNested() {return nested;}}class Nested {Inner inner;Inner getInner() {return inner;}}class Inner {String foo;String getFoo...
java astore_JVM指令手册
weixin_36294852的博客
02-16 2176
注：建议直接复制保存至本地，研究jvm运行，执行指令非常有帮助一、未归类系列A此系列暂未归类。指令码 助记符 说明0x00 nop 什么都不做0x01 aconst_null 将null推送至栈顶二、const系列该系列命令主要负责把简单的数值类型送到栈顶。该系列命令不带参数。注意只把简单的数值类型送到栈顶时，才使用如下的命令。比如对应int型才该方式只能把-1,0,1,2,3,4,5(分别采用i...
Java中invokedynamic字节码指令问题
08-26
主要介绍了Java中invokedynamic字节码指令问题,非常不错，具有一定的参考借鉴价值，需要的朋友可以参考下
JByteMod-1.6.1(java字节码编辑器)简介及下载
03-07
JByteMod - (Java字节码编辑器)工具简介: 强大而轻松地修改JAR文件的工具,其功能有: 编辑字段,编辑属性,编辑try-catch块,反编译,彩色语法, 标签, 多语言支持, LDC搜索,Instruction指令搜索, 正则表达式搜索,在编辑器...
Java字节码操纵框架 asm-3.1组件包大集合
12-04
Java class 被存储在严格格式定义的 .class 文件里，这些类文件拥有足够的元数据来解析类中的所有元素：类名称、方法、属性以及 Java 字节码（指令）。ASM 从类文件中读入信息后，能够改变类行为，分析类信息，甚至...
JavaBytecodeAnalyzer:解析学习 Java 字节码
05-15
JavaBytecodeAnalyzer 解析 Java 字节码，学习字节码指令集 解析 class 文件为字节码，以熟悉 class 文件结构 学习 java bytecode 指令集
JVM调优指令手册
欧阳俞峰的个人博客
08-28 1223
栈和局部变量操作 将常量压入栈的指令 aconst_null 将null对象引用压入栈 iconst_m1 将int类型常量-1压入栈 iconst_0 将int类型常量0压入栈 iconst_1 将int类型常量1压入栈 iconst_2 将int类型常量2压入栈 iconst_3 将int类型常量3压入栈 iconst_4 将int类型常量4压入栈 icon...
0,0.0,‘0‘,“0“占字节数量
12-20 6181
0为int类型，占4字节。 0.0为double类型，占8字节。 '0’为char类型，占1字节。 "0"为字符串，为char类型数组，有两个元素(“0\0”)占用1*2=2字节。 补充： 在x86上，指针为4字节。在x64上，指针为8字节。 可以使用sizeof(void*)来查看。 ...
JVM指令助记符
记录、分享技术总结，避坑经验等
05-29 905
JVM常用操作码助记符
JVM指令集
残缺的孤独
11-19 3019
本篇文章转载于http://blog.csdn.net/lm2302293/article/details/6713147  JVM指令集（指令码、助记符、功能描述） 指令码 助记符 功能描述 0x00 nop 无操作   0x01
java的字节码详解，
sinat_22988423的博客
02-17 656
  java对象 public class Demo{   private String name;     private int num;          public Demo(){     }     public Demo(String name1,int num1){         name = name1;         num = num1;         stor...
C语言 字符0 字节码,C语言中的BYTE和char深入解析
weixin_39668479的博客
05-17 251
例如，在下面的源程序中“""”之内的“你”、“好”、“，”、“C”、“!”、“\n”就属于程序要处理的字符。#include int main(void){printf("你好，C!\n");return 0;}该源程序中的其他字符则属于书写源程序的字符，这其中也可能包含并没有明显显示出来的字符，例如空格字符(space character)、水平制表符(horizontal tab)、垂直制表符...
byte类型 -0 和 -128的二进制原码都为 1000 0000？
大帅 的CSDN技术尬blog!
10-14 3461
byte类型 -0 和 -128的二进制原码都为 1000 0000？ 我们都知道，byte类型的取舍范围是-128~127.因为byte类型是1个字符 占8个比特位，最多能装256个数（每个位能表示2中可能，有8位，那么就有2的8次方种可能） 但是256是要考虑正负情况的，比如说单纯的+256，放在一个byte里面，是装不下的。 二进制规定，正数的原码就是其本身，而负数的原码是在最高位补1. ...
JVM指令集及各指令的详细使用说明
JeamKing的专栏
09-11 4691
一、JVM指令助记符 1)操作数栈 变量到操作数栈：iload,iload_,lload,lload_,fload,fload_,dload,dload_,aload,aload_ 操作数栈到变量：istore,istore_,lstore,lstore_,fstore
【JAVA】虚拟机指令集
noOnlyAndroid的专栏
01-05 2988
<br /><br />0x00 nop      什么都不做<br />0x01 aconst_null 将null推送至栈顶<br />0x02 iconst_m1   将int型-1推送至栈顶<br />0x03 iconst_0   将int型0推送至栈顶<br />0x04 iconst_1   将int型1推送至栈顶<br />0x05 iconst_2   将int型2推送至栈顶<br />0x06 iconst_3   将int型3推送至栈顶<br />0x07 iconst_4   将in
java assist_Java-Javaassist（一）
最新发布
06-10
Javaassist是一个开源的Java字节码编辑器库，它可以让Java开发人员在运行时动态地编辑字节码。使用Javaassist，我们可以在不重新编译代码的情况下修改已有的类或创建新的类，这使得我们能够在运行时动态地添加新的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值