38-Java方法的参数传递机制：值传递

一、基本类型的参数传递机制：值传递

• 在 传输实参 给 方法的形参 的时候，并 不是传输实参变量本身，而 是传输实参变量中存储的值，这就是 值传递

注意：

• 实参： 是指在方法内部定义的变量。
  

• 形参： 是指在 定义方法时，“()” 中所声明的参数。
  

package com.app.param;

public class Test3 {
    public static void main(String[] args) {
        int a = 10;
        change(a);  // 将 变量a中存储的值: 10 ——> 传递给 change()方法的形参: n 中
    }

    public static void change(int n) {
        System.out.println(n);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

输出结果：

10

1
2
3
4

通过解析面试题深入理解基本类型的值传递机制

package com.app.param;

public class Test3 {
    public static void main(String[] args) {
        // 目标：通过面试题，更深的理解基本类型的参数传递机制: 值传递
        int a = 10;
        change(a);
        System.out.println(a);  // 10
    }

    public static void change(int a) {
        System.out.println(a);  //  10
        a = 20;
        System.out.println(a);  //  20
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

输出结果：

10
20
10

1
2
3
4
5
6

图文解析

• 图1说明：

  1. 首先，会将 Test3.java 文件编译生成 Test3.class 字节码文件，存放在方法区；
  2. 接着，main()、change()方法 依次存放在方法区；
  3. 然后，会执行main()方法，进入到栈内存中，执行第一行 int a = 10;——>在栈内存中生成一块名叫a的区域，值为10；
  4. 接着，会执行main()方法的第二行 change(a);——>调用change()方法，并将实参a的值: 10 传递给change()方法的形参: a；
  5. 然后，会执行change()方法，进入到栈内存中，接收到实参: 10后，形参a的值: 10，开始执行第一行 System.out.println(a);——>输出形参a的值到控制台；
     

• 图2说明：

  1. 接着，会执行change()方法的第二行 a = 20;——>将值: 20 重新赋给 形参a中；
  2. 然后，会执行change()方法的第三行 System.out.println(a);——>将重新赋值后的形参a的值: 20，输出到控制台
     

• 图3说明：

  1. 接着，change()方法调用完毕后，退出栈
  2. 然后，会执行main()方法的第三行 System.out.println(a);——>将实参a的值: 10 输出到控制台
     

• 图4说明：

  1. 最后，main()方法调用完毕后，退出栈

  2. 最终控制台输出结果：

     10
     20
     10
     1
     2
     3

总结

1、形参和实参各指什么？

• 形参：指的是在定义方法时，“()” 中所声明的参数——>变量
• 实参：指的是在方法内部定义的变量

2、Java的参数传递机制是什么样的？

• 值传递：传输的是实参变量中存储的值

二、引用类型的参数传递

• 它的参数传递机制也是: 值传递 ，但是要区分其不同点

通过解析面试题深入理解引用类型的值传递机制

package com.app.param;

public class ParamDemo2 {
    public static void main(String[] args) {
        // 目标：通过面试题，更深入的理解引用类型的参数传递机制：值传递，区分其不同点
        int[] arrs = new int[]{10, 20, 30};
        // int[] arrs = {10, 20, 30};
        change(arrs);
        System.out.println(arrs[1]);    // 222
    }

    public static void change(int[] arrs) {
        System.out.println("第2个元素: " + arrs[1]);    // 20
        arrs[1] = 222;
        System.out.println("第2个元素: " + arrs[1]);    // 222
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果：

第2个元素: 20
第2个元素: 222
222

1
2
3
4
5
6

图文解析

• 图1说明：

  1. 首先，会将 ParamDemo2.java 编译生成 ParamDemo2.class 字节码文件，存放在方法区；
  2. 接着，main()、change()方法，都存放在方法区；
  3. 然后，会执行main()方法的代码功能，进入到栈内存，执行第一行的左边: int[] arrs ——>开辟一块名叫arrs的int类型的数组区域；
  4. 接着，会执行main()方法的第一行的右边: new int[]{10, 20, 30}; ——>在堆内存中，开辟一块区域，会生成一个内存地址: [I@3b9a45b3，元素: 10, 20, 30，索引: 0 1 2，长度: 3；
  5. 然后，会将这个内存地址: [I@3b9a45b3，赋给 arrs数组；
     

• 图2说明：

  1. 接着，会执行 main()方法的第二行: change(arrs);——> 调用change()方法，并将arrs数组的内存地址: [I@3b9a45b3 传递给 change()方法的形参: arrs；
  2. 然后，会执行 change()方法，进入到栈内存中，接收arrs的内存地址: [I@3b9a45b3；
  3. 接着，会执行 change()方法的第一行: System.out.println("第2个元素: " + arrs[1]); ——> 通过arrs数组的内存地址: [I@3b9a45b3，访问它的索引为1的元素: 20，将这个元素输出到控制台；
     

• 图3说明：

  1. 然后，会执行 change()方法的第二行: arrs[1] = 222; ——> 通过arrs的内存地址: [I@3b9a45b3 将值为222重新赋给 索引为1的元素，20 变成 222；
  2. 接着，会执行 change()方法的第三行: System.out.println("第2个元素: " + arrs[1]); ——> 通过arrs的内存地址: [I@3b9a45b3 访问索引为1的元素: 222，输出到控制台；
     

• 图4说明：

  1. 然后，change()方法调用完毕后，退出栈；
  2. 接着，会执行main()方法的第三行: System.out.println(arrs[1]); ——> 通过arrs的内存地址: [I@3b9a45b3 将索引为1的元素: 222 访问出来，输出到控制台；
     

• 图5说明：

  1. 最后，main()方法调用完毕后，退出栈；

  2. 最终输出结果：

     第2个元素: 20
     第2个元素: 222
     222
     1
     2
     3

总结

1、基本类型和引用类型的参数在传递的时候有什么不同？

• 都是值传递
• 区别：
  • 基本类型传递的参数是存储的数据值。
  • 引用类型传递的参数是存储的地址值。