java 参数为函数指针 java方法参数为对象

转载

gulaotou 2023-07-06 15:34:12

文章标签 java 参数为函数指针 java中对象作为参数 List main方法赋值 文章分类 Java 后端开发

概述

Java编程中，当对象作为参数传递给方法时候，是按引用传递的，但是有的人会说这实质上

是按值传递的。其实两者说的都不错，只是理解的方式不一样罢了，二者的原理其实是一样的。

说明

下面通过一个例子来详细说明Java对象作为方法参数的时候会出现的情况：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68import java.util.ArrayList;
import java.util.List;
/**
* 测试java的引用传值
*
* Created by Xuyh at 2017/01/05 上午 10:27.
*/
public class SetParamTest {
public static void main(String... args) {
// 集合对象，列表[a, b, c]
List testParam = new ArrayList();
testParam.add("a");
testParam.add("b");
testParam.add("c");
System.out.println("Old: " + testParam.toString() + "\r\n");
// 引用(地址)传值，并直接修改testParam指向对象的值
change(testParam);
System.out.println("Change1: " + testParam.toString() + "\r\n");
testParam.add("a");
// 引用(地址)传值，修改指向对象之后再将地址返回
testParam = change2(testParam);
System.out.println("Change2: " + testParam.toString() + "\r\n");
// 集合对象变为[b, c, d, e]
testParam.add("d");
testParam.add("e");
// 引用(地址)传值，方法内部new新集合对象并将地址赋给方法局部参数，
// 并不改变testParam的值，testParam仍然指向原地址
sort(testParam);
System.out.println("sort1: " + testParam.toString() + "\r\n");
// 引用(地址)传值，方法内部new新集合对象并将地址赋给方法局部参数，
// 并将新地址返回，再赋值给testParam，因此testParam指向的对象发生改变
testParam = sort2(testParam);
System.out.println("sort2: " + testParam.toString() + "\r\n");
}
public static void change(List param) {
if (param.contains("a"))
param.remove("a");
}
public static List change2(List param) {
if (param.contains("a"))
param.remove("a");
return param;
}
public static void sort(List param) {
List newParam = new ArrayList();
for (int i = param.size() - 1; i >= 0; i--) {
newParam.add(param.get(i));
}
param = newParam;
}
public static List sort2(List param) {
List newParam = new ArrayList();
for (int i = param.size() - 1; i >= 0; i--) {
newParam.add(param.get(i));
}
return newParam;
}
}

上面的例子简单的说就是一个列表，[a, b, c]，首先通过两个方法把其中的字符”a”去除，

然后通过两个方法对列表[b, c, d, e]进行倒序排序。同时在操作的过程中不断将main方法中的

testParam输出出来。

接着请看程序运行的结果：

1
2
3
4
5
6
7
8
9Old: [a, b, c]
Change1: [b, c]
Change2: [b, c]
sort1: [b, c, d, e]
sort2: [e, d, c, b]

由结果可以看到，两个change方法都将原来的testParam改变了，

而sort方法只有一个改变了testParam的值，这个有趣的现象接下来要好好说说了。

下面从四个比较典型的方法来介绍不同情况下对象作为值传入方法时候内存中的情况，

以便我们更好理解java的方法传值原理。

change方法1

2
3
4public static void change(List param) {
if (param.contains("a"))
param.remove("a");
}

testParam作为参数传递给param时候，内存内是这样的：

java 参数为函数指针 java方法参数为对象_List

testParam的地址值复制给了change方法局部变量param，于是param指向了与testParam相同的一个对象。

注意这时候param的引用(地址)值是testParam的一份拷贝。

Change方法中将列表的”a”元素去除时候的情况是这样的：

java 参数为函数指针 java方法参数为对象_main方法_02

此时testParam与param指向的对象(同一个)发生了改变，所以方法执行完毕之后输出testParam是发生改变的。

change2方法1

2
3
4
5public static List change2(List param) {
if (param.contains("a"))
param.remove("a");
return param;
}

与change方法类似，当对象在方法中发生改变时候，内存中的情况是这样的：

java 参数为函数指针 java方法参数为对象_赋值_03

1testParam = change2(testParam);

方法执行到最后，param会返回，也就是param的引用(地址)值会返回，

然后又拷贝给testParam(其实是多此一举，二者的地址值完全相同)。

所以方法执行完成之后输出的testParam是发生改变的。

sort方法1

2
3
4
5
6
7public static void sort(List param) {
List newParam = new ArrayList();
for (int i = param.size() - 1; i >= 0; i--) {
newParam.add(param.get(i));
}
param = newParam;
}

调用方法时候内存中是这样的

java 参数为函数指针 java方法参数为对象_main方法_04

接着，方法中new了一个新的对象，并在处理排序之后将新对象的引用(地址)赋值给param，这时候内存中的情况是这样的：

java 参数为函数指针 java方法参数为对象_List_05

可以看到，testParam与param指向的已经不是同一个地址了，并且testParam指向的对象仍然没有发生改变。因此方法执行完毕之后输出的结果看来，sort方法是没有用的。

sort2方法

最后我们来看一下sort2方法

1
2
3
4
5
6
7public static List sort2(List param) {
List newParam = new ArrayList();
for (int i = param.size() - 1; i >= 0; i--) {
newParam.add(param.get(i));
}
return newParam;
}

同sort方法类似，执行sort2方法前内存中是这样的：

java 参数为函数指针 java方法参数为对象_赋值_06