JAVA中值传递和引用传递的三种情况

JAVA中值传递和引用传递的三种情况

前言

我们都知道，java中数据类型分为基本数据类型和引用数据类型。

• 基本数据类型 
  
  • 整型：byte，short，int，long
  • 浮点型：float，double
  • 字符型：char
  • 布尔型：boolean
• 引用数据类型 
  
  • 数组
  • 类
  • 接口

方法的参数分为实际参数，和形式参数。

• 形式参数：定义方法时写的参数。
• 实际参数：调用方法时写的具体数值。

一般情况下，在数据做为参数传递的时候，基本数据类型是值传递，引用数据类型是引用传递（地址传递）。

值传递

public static void main(String[] args) {
    int num1 = 10;
    int num2 = 20;

    swap(num1, num2);

    System.out.println("num1 = " + num1);
    System.out.println("num2 = " + num2);
}

public static void swap(int a, int b) {
    int temp = a;
    a = b;
    b = temp;

    System.out.println("a = " + a);
    System.out.println("b = " + b);
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18

运行的结果是：

a = 20
b = 10
num1 = 10
num2 = 20

• 1
• 2
• 3
• 4

原因：

流程：

1. 主函数进栈，num1、num2初始化。
2. 调用swap方法，swap( )进栈，将num1和num2的值，复制一份给a和b。
3. swap方法中对a、b的值进行交换。
4. swap方法运行完毕，a、b的值已经交换。
5. swap方法弹栈。
6. 主函数弹栈。

解析：

在swap方法中，a、b的值进行交换，并不会影响到num1、num2。因为，a、b中的值，只是从num1、num2的复制过来的。 
也就是说，a、b相当于num1、num2的副本，副本的内容无论怎么修改，都不会影响到原件本身。

引用传递

public static void main(String[] args) {
    int[] arr = {1,2,3,4,5};

    change(arr);

    System.out.println(arr[0]);
}

//将数组的第一个元素变为0
public static void change(int[] array) {
    int len = array.length;
    array[0] = 0;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13

运行的结果是：

0

• 1

原因：

流程：

1. 主函数进栈，int[] arr初始化。
2. 调用change方法，change( )进栈，将arr的地址值，复制一份给array。
3. change方法中，根据地址值，找到堆中的数组，并将第一个元素的值改为0。
4. change方法运行完毕，数组中第一个元素的值已经改变。
5. change方法弹栈。
6. 主函数弹栈。

解析：

调用change()的时候，形参array接收的是arr地址值的副本。并在change方法中，通过地址值，对数组进行操作。change方法弹栈以后，数组中的值已经改变。main方法中，打印出来的arr[0]也就从原来的1变成了0.

无论是主函数，还是change方法，操作的都是同一个地址值对应的数组。 
就像你把自己家的钥匙给了另一个人，这个人拿着钥匙在你家一顿瞎折腾，然后走了。等你拿着钥匙回到家以后，家里已经变成了被折腾过后，惨不忍睹的样子。。 
这里的钥匙就相当于地址值，家就相当于数组本身。

String类型传递

public static void main(String[] args) {
    String str = "AAA";

    change(str);

    System.out.println(str);
}   
public static void change(String s) {
    s = "abc";
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10

运行的结果是：

AAA

• 1

这就神奇了！！！ 
String是一个类，类是引用数据类型，做为参数传递的时候，应该是引用传递。但是从结果看起来却是值传递。

原因：

String的API中有这么一句话：“their values cannot be changed after they are created”， 
意思是：String的值在创建之后不能被更改。 
API中还有一段： 
String str = "abc"; 
等效于： 
char data[] = {'a', 'b', 'c'}; 
String str = new String(data); 
也就是说：对String对象str的任何修改 等同于 重新创建一个对象，并将新的地址值赋值给str。

这样的话，上面的代码就可以写成：

public static void main(String[] args) {
    String str1 = "AAA";

    change(str1);

    System.out.println(str1);
}   
public static void change(String s) {
    char data[] = {'a', 'b', 'c'}
    String str = new String(data);
    s = str;
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

流程：

1. 主函数进栈，str1初始化。
2. 调用change方法，change( )进栈，将str1的地址值，复制一份给s。
3. change方法中，重现创建了一个String对象”abc”，并将s指向了新的地址值。
4. change方法运行完毕，s所指向的地址值已经改变。
5. change方法弹栈。
6. 主函数弹栈。

解析：

String对象做为参数传递时，走的依然是引用传递，只不过String这个类比较特殊。 
String对象一旦创建，内容不可更改。每一次内容的更改都是重现创建出来的新对象。 
当change方法执行完毕时，s所指向的地址值已经改变。而s本来的地址值就是copy过来的副本，所以并不能改变str1的值。

String类型类似情况：

class Person {
    String name;

    public Person(String name) {
        this.name = name;
    }
}
public class Test {
    public static void main(String[] args) {
        Person p = new Person("张三");

        change(p);

        System.out.println(p.name);
    }

    public static void change(Person p) {
        Person person = new Person("李四");
        p = person; 
    }
}

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21

运行的结果是：

张三

• 1

总结

• 值传递的时候，将实参的值，copy一份给形参。
• 引用传递的时候，将实参的地址值，copy一份给形参。

也就是说，不管是值传递还是引用传递，形参拿到的仅仅是实参的副本，而不是实参本身。