Java 中方法的参数传递机制

1、实参和形参

  在解释什么是值传递和地址传递前，我们先引入两个概念：实参和形参。

  实参：在调用有参函数时，主调函数和被调函数之间有数据传递关系。在主调函数中调用一个函数时，函数名后面括号中的参数称为“实际参数”，简称“实参”。

  形参：在定义函数名和函数体的时候使用的参数称为“形式参数”，简称“形参”，目的是用来接收调用该函数时传入的参数。

在代码中：

 1public class Main {
 2
 3    public static void main(String[] args) {
 4        int a = 1;
 5	// 实参
 6        passByValue(a);
 7    }
 8    // 形参
 9    public static void transmit(int a) {
10    }
11}

2、什么是值传递

  值传递是指在调用函数（方法）时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

例如

  我们在 main 方法中创建一个变量 a，然后调用 passByValue 方法修改变量 a 的值。

 1public class Main {
 2
 3    public static void main(String[] args) {
 4        int a = 1;
 5        System.out.println("调用前" + a);
 6        passByValue(a);
 7        System.out.println("调用后" + a);
 8    }
 9
10    public static void passByValue(int a) {
11        // 改变a的值
12        a = a + 1;
13        System.out.println("方法中" + a);
14    }
15}

控制台的打印结果

1调用前1
2方法中2
3调用后1

  我们发现 main 方法中 a 变量的值并没有因为调用 passByValue 方法而发生改变。因为在调用方法时是将实际参数复制一份传递到方法中，main 方法中的 a 和 passByValue 方法中的 a 不在一个内存地址中，所以在方法中修改形式参数的值，并不会影响到实际参数的值。

3、什么是地址传递

  地址传递也叫引用传递是指在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

例如

  我们自定义一个 User 类，然后在 main 方法中创建该类的实例并赋初值，接着调用 addressPassing 方法修改 User 类中的值。

 1public class Main {
 2
 3    public static void main(String[] args) {
 4        User user = new User();
 5        user.id = 1;
 6        user.name = "Yi-Xing";
 7        System.out.println("调用前" + user);
 8        addressPassing(user);
 9        System.out.println("调用后" + user);
10    }
11
12    public static void addressPassing(User user) {
13        // 改变user的值
14        user.id = 2;
15        user.name = "zyxwmj.top";
16        System.out.println("方法中" + user);
17    }
18
19    static class User {
20        int id;
21        String name;
22
23        @Override
24        public String toString() {
25            return "User{" +
26                    "id=" + id +
27                    ", name='" + name + '\'' +
28                    '}';
29        }
30    }
31}

控制台的打印结果

1调用前User{id=1, name='Yi-Xing'}
2方法中User{id=2, name='zyxwmj.top'}
3调用后User{id=2, name='zyxwmj.top'}

  我们发现 main 方法中 user 对象的值因为调用 addressPassing 方法而发生改变。因为在调用方法时是将实际参数的内存地址传递给了形参，main 方法中的 user 和 passByValue 方法中的 user 指向了同一块内存地址，所以在方法中修改形式参数的值，会影响到实际参数的值。

  如果我们不重写 User 类的 toString 方法，Java 则会将 user 的内存地址打印在控制台上，运行结果如下：

1调用前blog.Main$User@1f32e575
2方法中blog.Main$User@1f32e575
3调用后blog.Main$User@1f32e575

  正如我们所想 main 方法中的 user 和 addressPassing 方法中的 user 是指向同一块内存地址。

重点

  但有人提出质疑了，并搬出一下代码。

 1public class Main {
 2
 3    public static void main(String[] args) {
 4        User user = new User();
 5        user.id = 1;
 6        user.name = "Yi-Xing";
 7        System.out.println("调用前" + user);
 8        addressPassing(user);
 9        System.out.println("调用后" + user);
10    }
11
12    public static void addressPassing(User user) {
13        user = new User();
14        // 改变user的值
15        user.id = 2;
16        user.name = "zyxwmj.top";
17        System.out.println("方法中" + user);
18    }
19
20    static class User {
21        int id;
22        String name;
23
24        @Override
25        public String toString() {
26            return "User{" +
27                    "id=" + id +
28                    ", name='" + name + '\'' +
29                    '}';
30        }
31    }
32}

控制台的打印结果

1调用前User{id=1, name='Yi-Xing'}
2方法中User{id=2, name='zyxwmj.top'}
3调用后User{id=1, name='Yi-Xing'}

  不难发现，在 addressPassing 方法中修改了 user 的值并没有影响到 main 中的 user。实际上在方法调用时， addressPassing 方法中的 user 和 main 方法中的 user 指向同一块内存，只不过我们在 addressPassing 方法中又从新对 user 进行了赋值更改了指向的内存地址，赋值后的 user 和 main 方法中的 user 指向不同的内存地址。具体代码如下：

 1public class Main {
 2
 3    public static void main(String[] args) {
 4        User user = new User();
 5        user.id = 1;
 6        user.name = "Yi-Xing";
 7        System.out.println("调用前" + user);
 8        addressPassing(user);
 9        System.out.println("调用后" + user);
10    }
11
12    public static void addressPassing(User user) {
13        System.out.println("赋值前" + user);
14        user = new User();
15        System.out.println("赋值后" + user);
16        // 改变user的值
17        user.id = 2;
18        user.name = "zyxwmj.top";
19        System.out.println("方法中" + user);
20    }
21
22    static class User {
23        int id;
24        String name;
25    }
26}

控制台的打印结果

1调用前blog.Main$User@1f32e575
2赋值前blog.Main$User@1f32e575
3赋值后blog.Main$User@279f2327
4方法中blog.Main$User@279f2327
5调用后blog.Main$User@1f32e575

  运行结果正如我们所想，赋值前、调用前、调用后的 user 指向同一块内存地址。

对象不可变性

 1public class Main {
 2
 3    public static void main(String[] args) {
 4        String str = "hello";
 5        Integer num = 2;
 6        Float f = 2f;
 7        change(str, num,f);
 8        System.out.println("str = " + str);
 9        System.out.println("num = " + num);
10        System.out.println("f = " + f);
11    }
12
13    public static void change(String s, Integer n,Float f) {
14        s += "world";
15        n += 1;
16        f = 3f;
17    }
18}

  以上代码的运行结果为：

1str = hello
2num = 2
3f = 2.0

  String，Integer，Float 这些对象都是引用类型，方法传参时，传递的是内存地址，为什么在 change 方法内更改了变量值后，main 方法中的变量没有受影响呢？

  因为 String 和 Integer 等包装类都具有对象不可变性，对象值在进行改变时，并不是在原内存上进行修改值，而是创建新的内存空间，让变量指针指向新的内存空间。

  change 方法中的变量指向了新的内存空间，而 main 方法中的变量还指向原内存空间，所以值还是原来的值。

4、结论

• 形参是基本数据类型：
  • 传递数据值。
• 形参是引用数据类型：
  • 传递地址值；
  • 特殊的类型：String、包装类等对象不可变性。

 1public class Exam4 {
 2
 3    public static void main(String[] args) {
 4        int i = 1;
 5        String str = "hello";
 6        Integer num = 2;
 7        int[] arr = {1, 2, 3, 4, 5};
 8        MyData my = new MyData();
 9        change(i, str, num, arr, my);
10        System.out.println("i = " + i);
11        System.out.println("str = " + str);
12        System.out.println("num = " + num);
13        System.out.println("arr = " + Arrays.toString(arr));
14        System.out.println("my.a = " + my.a);
15    }
16
17    public static void change(int j, String s, Integer n, int[] a, MyData m) {
18        j += 1;
19        s += "world";
20        n += 1;
21        a[0] += 1;
22        m.a += 1;
23    }
24}
25
26class MyData {
27    int a = 10;
28}

  运行结果：

1i = 1
2str = hello
3num = 2
4arr = [2, 2, 3, 4, 5]
5my.a = 11