一个小问题

在开源中国看到这样一则问题

我答错了，我认为传入function的就是main函数中的a，在function中修改了a的地址，因此回到主函数后，a的地址已经变成了function中所赋予的a2的地址，因此经过function处理后a的值已经改变了。

但结果并不是，因为我忽略了Java的基础知识点之一。

Java中传参都是值传递，如果是基本类型，就是对值的拷贝，如果是对象，就是对引用地址的拷贝。

下文将从字节码的角度，分析Java中基本类型传参和对象传参。

基本类型传参

以下是处理类Porcess，代码应该已经能够自解释了。function1是将传参a变成2，function2是初始化int b，赋值为5，然后将b赋值给a。

public class Process {

public void function3(int a) {

a = 2;

}

public void function4(int a) {

int b = 5;

a = b;

}

}

我们继续看测试类TestPrimitive

public class TestPrimitive {

public static void main(String[] args) {

Process process = new Process();

int age = 18;

System.out.println(age);

process.function3(age);

System.out.println(age);

}

}

结果是在经过function3的处理后，输出结果是

18

18

修改测试类代码，在经过function4处理后，仍然一致。

18

18

结论: 基本类型的传参，对传参进行修改，不影响原本参数的值。

对象类型传参

以下是处理类Porcess，function1，将参数car的颜色设置成blue。function2，新建了car2，将car2赋值给了参数car。

public class Process {

public void function1(Car car) {

car.setColor("blue");

}

public void function2(Car car) {

Car car2 = new Car("black");

car = car2;

car.setColor("orange");

}

}

我们继续看测试类TestReference

public class TestReference {

public static void main(String[] args) {

Process process = new Process();

Car car = new Car("red");

System.out.println(car);

process.function1(car);

System.out.println(car);

}

}

结果是在经过function1的处理后，输出结果是

Car{color='red'}

Car{color='blue'}

修改测试类，在经过function2的处理后

Car{color='red'}

Car{color='red'}

结论: 对象类型的传参，直接调用传参set方法，可以对原本参数进行修改。如果修改传参的指向地址，调用传参的set方法，无法对原本参数的值进行修改。

综上所述，基本类型的传参，在方法内部是值拷贝，有一个新的局部变量得到这个值，对这个局部变量的修改不影响原来的参数。对象类型的传参，传递的是堆上的地址，在方法内部是有一个新的局部变量得到引用地址的拷贝，对该局部变量的操作，影响的是同一块地址，因此原本的参数也会受影响，反之，若修改局部变量的引用地址，则不会对原本的参数产生任何可能的影响。

上文已经得到结论，我们从JVM的字节码的角度看一下过程是怎么样的。

首先大致JVM的基本结构，对基本类型，和对象存放的位置有一个大致的了解。下图是JVM的基本组件图。

介绍几个基本的组件

程序计数器: 存储每个线程下一步将执行的JVM指令。

JVM栈(JVM Stack): JVM栈是线程私有的，每个线程创建的同时都会创建JVM栈，JVM栈中存放的为当前线程中局部基本类型的变量(java中定义的八种基本类型：boolean、char、byte、short、int、long、float、double)、部分的返回结果以及Stack Frame(每个方法都会开辟一个自己的栈帧)，非基本类型的对象在JVM栈上仅存放一个指向堆上的地址

堆(heap): JVM用来存储对象实例以及数组值的区域，可以认为Java中所有通过new创建的对象的内存都在此分配，Heap中的对象的内存需要等待GC进行回收。

方法区(Method Area): 方法区域存放了所加载的类的信息(名称、修饰符等)、类中的静态变量、类中定义为final类型的常量、类中的Field信息、类中的方法信息，当开发人员在程序中通过Class对象中的getName、isInterface等方法来获取信息时，这些数据都来源于方法区域。

本地方法栈(Native Method Stacks): JVM采用本地方法栈来支持native方法的执行，此区域用于存储每个native方法调用的状态。

运行时常量池(Runtime Constant Pool): 存放的为类中的固定的常量信息、方法和Field的引用信息等，其空间从方法区域中分配。JVM在加载类时会为每个class分配一个独立的常量池，但是运行时常量池中的字符串常量池是全局共享的。

下图是从另一个角度解析JVM的结构，JVM是基于栈来操作的，每一个线程有自己的操作栈，遇到方法调用时会开辟栈帧，它含有自己的返回值，局部变量表，操作栈，以及对常量池的符号引用。

如果是基本类型，则存放在栈里的是值，如果是对象，存放在栈上是对象在堆上存放的地址。

了解了JVM的基本结构，我们来看一下上述的两种代码，一种是基本类型传参，一种是对象传参，在字节码表现上的不同。

使用javap对字节码进行反编译

javap -verbose Main

基本类型传参字节码

以下是TestPrimitive类在执行function3时的字节码。

public static void main(java.lang.String[]);

flags: ACC_PUBLIC, ACC_STATIC

Code:

stack=2, locals=3, args_size=1

0: new #2 // class Process

3: dup

4: invokespecial #3 // Method Process."":()V

7: astore_1

8: bipush 18

10: istore_2

11: getstatic #4 // Field java/lang/System.out:Ljava/io/PrintStream;

14: iload_2

15: invokevirtual #5 // Method java/io/PrintStream.println:(I)V

18: aload_1

19: iload_2

20: invokevirtual #6 // Method Process.function3:(I)V

23: getstatic #4 // Field java/lang/System.out:Ljava/io/PrintStream;

26: iload_2

27: invokevirtual #5 // Method java/io/PrintStream.println:(I)V

30: return

LineNumberTable:

...........

LocalVariableTable:

Start Length Slot Name Signature

0 31 0 args [Ljava/lang/String;

8 23 1 process LProcess;

11 20 2 age I

主函数执行时，JVM操作栈会推入主函数栈帧，其中包含了主函数的局部变量表，字节码，返回值等信息。LocalVariableTable就是局部变量表,以0为索引起点，第0个是局部变量String数组 args,第1个是局部变量process，保存新创建的Process对象的引用地址。第2个是局部变量age。在字节码第8行，通过bipush 18，将常量18直接压入操作栈，然后第20行，是调用了process的function3方法，传入了age作为参数。

然后JVM操作栈将function3栈帧推入JVM栈，使得function3栈帧成为当前栈帧，开始执行。

public void function3(int);

flags: ACC_PUBLIC

Code:

stack=1, locals=2, args_size=2

0: iconst_2

1: istore_1

2: return

LocalVariableTable:

Start Length Slot Name Signature

0 3 0 this LProcess;

0 3 1 a I

字节码显示，通过iconst_2，istore_1，将基本类型2推入栈，并保存在局部变量a中，这里就展示了我们在方法内部的修改都是对function3的局部变量a的值修改，不影响主函数中的a。从主函数的字节码中可以看到，它的值保存的还是第10行，通过istore_2保存到局部变量第2个索引处的18.

如果用图示来表示上述字节码执行过程中，JVM栈，man函数栈帧，function3栈帧内部变化的话，如下图所示。

1.主函数的栈帧会被推入JVM栈，成为当前操作栈。

2.然后进去main函数栈帧，初始化完毕后如下图所示。

3.主要看bipush 18，将基本变量18推入操作栈，基本变量类型是存储在栈帧内部的。

4.然后执行istore_2, 将栈顶出栈，并且保存在局部变量索引2处。

5.然继续执行至18: aload_1,，将创建的process的地址保存在局部变量索引1处,19:iload_2，将局部变量2处保存的基本类型压入栈。

6.然后执行至20：invokevirtula #6,也就是调用function3，进入function3的栈帧。执行0: iconst_2，将常量2推入栈，此时function3的栈帧有一个局部变量1处保存着传入的参数18。

7.继续执行1:istore_1，将栈顶推出，保存在局部变量1处，覆盖了传入的参数18，然后return，将function3函数栈帧弹出JVM栈，继续执行main函数栈帧。

之后会继续执行main函数栈帧，在function3函数栈帧中发生的一切都和Main Stack中的局部变量age的值没有任何关系。

对象类型传参字节码

以下是TestReference类在执行function2时的字节码。

Code:

stack=3, locals=3, args_size=1

0: new #2 // class Process

3: dup

4: invokespecial #3 // Method Process."":()V

7: astore_1

8: new #4 // class Car

11: dup

12: ldc #5 // String red

14: invokespecial #6 // Method Car."":(Ljava/lang/String;)V

17: astore_2

18: getstatic #7 // Field java/lang/System.out:Ljava/io/PrintStream;

21: aload_2

22: invokevirtual #8 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V

25: aload_1

26: aload_2

27: invokevirtual #9 // Method Process.function2:(LCar;)V

30: getstatic #7 // Field java/lang/System.out:Ljava/io/PrintStream;

33: aload_2

34: invokevirtual #8 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V

37: return

LocalVariableTable:

Start Length Slot Name Signature

0 38 0 args [Ljava/lang/String;

8 30 1 process LProcess;

18 20 2 car LCar;

我们可以通过字节码14-17行，看到局部变量索引2处存放的是Car的实例在堆上的地址，这和基本类型不同，基本类型的值都是直接存放在栈里面的。然后通过字节码第27行将car的引用地址传入function2。接下来我们看看function2的字节码。

public void function2(Car);

flags: ACC_PUBLIC

Code:

stack=3, locals=3, args_size=2

0: new #4 // class Car

3: dup

4: ldc #5 // String black

6: invokespecial #6 // Method Car."":(Ljava/lang/String;)V

9: astore_2

10: aload_2

11: astore_1

12: aload_1

13: ldc #7 // String orange

15: invokevirtual #3 // Method Car.setColor:(Ljava/lang/String;)V

18: return

LocalVariableTable:

Start Length Slot Name Signature

0 13 0 this LProcess;

0 13 1 car LCar;

10 3 2 car2 LCar;

题外话，因为这个是调用具体实例的函数，所以索引0处保存的是实例的引用。索引1保存的是传参car的引用地址，car2保存的是函数内创建的Car实例的地址。字节码0-9，完成了car2的引用地址保存，第10行将Car2的引用地址推入栈，第11行通过astore_1,将栈顶值保存到第一个局部变量，也就是修改了覆盖了局部变量car的引用地址。因此第15行，修改的是car当前引用的地址的实例的参数值。当退出栈帧，回到主函数，主函数的局部变量a保存的引用地址没有改变。

如果用图示来表示上述字节码执行过程中，JVM栈，man函数栈帧，function3栈帧内部变化的话，如下图所示。

1.main函数栈帧和上文测试基本类型传参时的字节码大致类似，不同的是局部变量处。局部变量2处保存的是main函数中新建的Car实例的堆上地址。对象的实际存放都是在堆中，栈帧的局部变量中保存的是他们在堆上的地址。

2.一直执行到调用function2，进入function2栈帧。在执行至9:astore_2时，栈中新创建的Car实例的引用地址出栈，保存在局部变量2处。局部变量1保存的是传参进来的Car实例的引用地址。

3.然后执行至10: aload_2,11:store_1，在这里，1236df被推入栈，然后保存在了局部变量1，覆盖了局部变量car本来的引用地址。

**

因此，当function2对局部变量2进行相关操作时，影响的都是1236df这块地址，和main函数局部变量car中保存的1235df不是一块地址，所以前后打印结果一致。**

测试类TestReference调用function1时，function1没有改变局部变量car的引用地址，保存的仍然是传入的引用地址，所以function1中car进行的操作影响了这块地址保存的内容，导致了前后打印结果不一致。

Code:

stack=2, locals=2, args_size=2

0: aload_1

1: ldc #2 // String blue

3: invokevirtual #3 // Method Car.setColor:(Ljava/lang/String;)V

6: return

LocalVariableTable:

Start Length Slot Name Signature

0 7 0 this LProcess;

0 7 1 car LCar;

本文对Java基本类型传参和对象传参，从字节码角度进行了分析，现在不会再搞错了吧~