【Java SE】值传递，看这一篇就够了！

一. 🦁 实参？形参？

程序设计语言在使用方法时（有些叫函数），都有可能会涉及到传递参数，而参数在其中分为两类：

• 实参（实际参数，Arguments）：用于传递给函数/方法的参数，必须有确定的值。
• 形参（形式参数，Parameters）：用于定义函数/方法，接收实参，不需要有确定的值。

String lion = "lion!";
// lion 为实参
sayLion(lion );
// str 为形参
void sayLion(String str) {
    System.out.println(str);
}

二. 🦁 值传递和引用传递

一般传递实参给方法的过程中，有两种传递方式，如下：

• 值传递：方法接收的是实参值的拷贝，会创建副本。
• 引用传递：方法接收的直接是实参所引用的对象在堆中的地址，不会创建副本，对形参的修改将影响到实参。

在Java中，参数传递都是值传递,默读100遍

三. 🦁 值传递到底传递啥？

1. 传递基本参数类型

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);
}

输出：

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

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

2. 自定义对象类型参数传递

public class Person {
    private String name;
   // 省略构造函数、Getter&Setter方法
}

public static void main(String[] args) {
    Person xiaoZhang = new Person("小张");
    Person xiaoLi = new Person("小李");
    swap(xiaoZhang, xiaoLi);
    System.out.println("xiaoZhang:" + xiaoZhang.getName());
    System.out.println("xiaoLi:" + xiaoLi.getName());
}

public static void swap(Person person1, Person person2) {
    Person temp = person1;
    person1 = person2;
    person2 = temp;
    System.out.println("person1:" + person1.getName());
    System.out.println("person2:" + person2.getName());
}

输出：

person1:小李
person2:小张
xiaoZhang:小张
xiaoLi:小李

这里的结果很明显也是和基本数据类型一致，swap方法里面的值互换之后，而实参的值并没有收到影响，这是不是就更坚定了Java的参数传递是值传递的！！！

3. 数组对象参数传递

tips: 在Java中，数组也是对象！！！

	public static void main(String[] args) {
      int[] arr = { 1, 2, 3, 4, 5 };
      System.out.println(arr[0]);
      change(arr);
      System.out.println(arr[0]);
	}

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

输出：

1
0

看到这，之前好不容易建立起来的信念是不是突然坍塌了？？？
这不就是引用传递才会发生么？别急！听我解释（辩解 ）一番。

专家的解释：
虽然数组也是对象，但它是一个容器，里面存储的是实际的数据，在方法调用中传递的是指向该容器的引用，因此交换数组中的两个元素时，只是修改了数组本身内部的元素，而实际的数组本身并没有发生改变，所以调用方法后，实参的原来值会被修改。

意思其实就是这个数组虽然也是一个对象，但是在参数传递的过程中，传递的仅仅是数组的地址；因此在这个时候，形参和实参指向的都是同一个数组地址，当形参改变数组内部的数据时，实参也会随之变化（因为修改数据时，数组本身的地址是没有发生变化的）。

思考：

1. 初始化一个数组，swap(a[1],a[2])；实际上的a[1]，a[2]会变化么？
2. 自定义一个对象B，对象里面有两个成员变量（name1，name2），实例化该对象 b，并且swap(b)，在swap()里面交换name1和name2，实参如何变化？（实验完这个，你就理解三.3了）

四. 🦁 小结

Java 中将实参传递给方法（或函数）的方式是 值传递：

• 如果参数是基本类型的话，很简单，传递的就是基本类型的字面量值的拷贝，会创建副本。

Java中，参数传递有两种方式：值传递和引用传递。本文主要介绍Java的值传递。

Java的值传递指的是将变量的值传递给另一个方法或函数，而不是将变量本身传递给其他方法或函数。在Java中，基本数据类型如int、float、char等是属于值类型，而对象类型如String、ArrayList、Map等是属于引用类型。

当传递基本数据类型的变量时，实际上传递的是该变量的值，而不是该变量本身。例如：

public static void changeValue(int num){
    num = 10;
}

public static void main(String[] args) {
    int a = 5;
    System.out.println("Before method call: a = " + a);
    changeValue(a);
    System.out.println("After method call: a = " + a);
}

运行结果为：

Before method call: a = 5
After method call: a = 5

可以看到，虽然在changeValue方法中将num赋值为10，但是在main方法中输出a的值却仍然为5。这是因为changeValue方法只是改变了num的值，而不会影响到a本身。

当传递引用类型的变量时，实际上传递的是该变量对应的对象的引用，而不是该对象本身。例如：

public static void changeValue(ArrayList<Integer> list){
    list.add(10);
}

public static void main(String[] args) {
    ArrayList<Integer> list = new ArrayList<>();
    list.add(5);
    System.out.println("Before method call: list = " + list);
    changeValue(list);
    System.out.println("After method call: list = " + list);
}

运行结果为：

Before method call: list = [5]
After method call: list = [5, 10]

可以看到，在changeValue方法中向list中添加了一个元素10，而在main方法中输出list的值时，list的值也被改变了。这是因为list传递的是对象的引用，而list.add(10)实际上是在对象本身上进行操作。

总结来说，在Java中，基本数据类型采用值传递，而对象类型采用引用传递。在传递对象类型的变量时，需要注意对象本身是否会被改变。