跳到主要内容
约 8 分钟4 张卡

Java 值传递

Java 只有值传递。

传递基本类型时,复制的是具体的值;传递引用类型时,复制的是引用值。

1. 面试核心​

先记住这几条,再读正文
  • 基本类型的变量存的是具体的值,引用类型的变量存的是引用值或 null,对象本身并不在变量里。
  • 赋值和传参都是复制变量当前的值。引用类型复制的是引用值,所以复制之后,两个变量指向同一个对象。卡 · 变量保存的值
  • 通过形参修改对象,调用方能看到;给形参重新赋值,只影响形参自己。 卡 · 赋值与传参卡 · 参数交换
  • final 变量赋值后不能再次赋值。如果它保存的是引用,引用的指向不能改变,但对象本身的可变内容仍可修改。卡 · final 变量
  • 引用数组的 clone() 是浅拷贝,复制后的数组和原数组仍然共享元素引用指向的对象。卡 · final 变量

2. 核心术语​

术语含义与例子
变量
variable
用来保存值的存储位置,有自己的类型。例如 int original = 101 中,original 是一个 int 变量。
值
value
可以存入变量、传给方法或从方法返回的数据。Java 的值分为基本值和引用值,例如整数 101 是基本值,对象的引用是引用值。
对象
object
类的实例或数组。例如 new User("Lin") 创建一个 User 实例,new int[3] 创建一个数组,两者都是对象。
引用值
reference value,简称 reference
指向对象的值;特殊的空引用 null 不指向任何对象。例如 User first = new User("Lin") 中,first 保存的是新对象的引用。
实参
argument
调用方法时提供的表达式,求值结果称为实参值。例如 rename(first) 中的 first 是实参,求值后得到它保存的引用;实参也可以是 101、count + 1 这样的表达式。
形参
formal parameter
方法声明中用于接收实参值的变量。例如 void rename(User user) 中的 user。每次调用都会创建新的形参变量。
调用方
caller
发起方法调用的代码。例如 main 中执行 rename(first),main 就是调用方,rename 是被调用的方法。
值传递
pass by value
形参保存实参值的一份副本。给形参重新赋值,不会改变调用方的变量。
引用传递
pass by reference
形参是调用方变量的别名。给形参赋值,会改变调用方的变量。

3. 变量保存的值​

Java 的数据类型分为基本类型和引用类型。基本类型的变量保存基本值;引用类型的变量保存引用值,也就是对象的引用或 null。

int、double、boolean 都是基本类型。把一个基本类型变量赋给另一个变量,会复制它保存的基本值:

int original = 101;
int copied = original;
copied = 202;

System.out.println(original); // 101

copied 拿到的是 101 这个数。之后把它改成 202,和 original 没有关系,所以 original 还是 101。

给引用类型的变量赋值,复制的就是引用值。下面用 new 创建一个 User 对象,再把 first 保存的引用赋给 second:

User first = new User("Lin");
User second = first;

System.out.println(first == second); // true

first 和 second 是两个变量,保存着同一个 User 对象的引用。这里的 == 比较两个引用是否指向同一个对象,所以结果是 true。赋值复制了引用,没有复制对象。

4. 赋值与传参​

传参时,形参得到的是实参值的一份副本。

4.1 修改对象与重新赋值​

通过形参修改对象,会影响所有指向这个对象的变量;给形参重新赋值,只改变形参自己的指向。下面的 main 依次调用 rename 和 replace,观察两次调用后 first 指向的对象:

public static void main(String[] args) {
User first = new User("Lin");

rename(first);
System.out.println(first.getName()); // Asuka

replace(first);
System.out.println(first.getName()); // Asuka
}

static void rename(User user) {
user.setName("Asuka");
}

static void replace(User user) {
user = new User("Rei");
}

执行 rename(first) 时,first 保存的引用会复制给形参 user,类似于上一节的 User second = first。first 和 user 是两个独立变量,指向同一个对象。user.setName("Asuka") 修改了这个对象的 name 字段,所以第一次输出是 Asuka。

接着执行 replace(first),这次调用会创建新的形参 user,它最初也指向名字已经变成 Asuka 的原对象。user = new User("Rei") 让 user 指向了新对象,first 保存的引用没有变,因此第二次输出仍是 Asuka。

下图展示两个方法执行完修改操作、尚未返回时的引用关系:

rename(first)main 中的变量firstuser形参Username = Asuka修改共享对象,first 读到 Asukareplace(first)main 中的变量firstuser形参Username = AsukaUser(新对象)name = Rei原来的指向只改 user 的指向,first 仍读到 Asuka

4.2 参数交换​

在方法里交换两个形参,不能交换调用方变量保存的引用。例如,想让 main 中的 first 改为指向名字为 Asuka 的对象,second 改为指向名字为 Lin 的对象,下面的 swap 做不到:

public static void main(String[] args) {
User first = new User("Lin");
User second = new User("Asuka");

swap(first, second);

System.out.println(first.getName()); // Lin
System.out.println(second.getName()); // Asuka
}

static void swap(User a, User b) {
User temp = a;
a = b;
b = temp;
}

调用 swap(first, second) 时,a 得到 first 保存的引用,b 得到 second 保存的引用。方法里交换的是 a 和 b 的值,main 中的 first 和 second 没有被重新赋值,因此输出顺序仍是 Lin、Asuka。

5. 数组与 String​

数组和 String 也是引用类型,传参时一样复制引用值。它们的区别在于,数组的内容能改,String 的内容不能改。先看数组:

static void update(int[] values) {
values[0] = 101;
values = new int[] {202};
}

int[] numbers = {1};
update(numbers);
System.out.println(numbers[0]); // 101

values[0] = 101 改的是调用方和形参共用的那个数组,所以调用方读到 101。下一行给 values 赋了一个新数组,这只影响形参,numbers 还指着原来的数组。

再看 String:

static void append(String value) {
value = value + " 101";
}

String title = "Coding";
append(title);
System.out.println(title); // Coding

String 的内容不能修改,所以 value + " 101" 会生成一个新的字符串,再把新字符串的引用赋给形参 value。这一步和前面的 replace 一样,调用方的 title 不受影响,输出还是 Coding。

String 在传参时没有特殊处理,它和其他引用类型走的是同一套规则,只是它自己的内容改不了。

6. final 引用与浅拷贝​

6.1 final 变量​

final 修饰的变量只能赋值一次。赋值后,再给这个变量赋值会编译报错:

final int number = 101;
// number = 202; // 编译错误:number 已经赋过值

对于基本类型,变量保存的是基本值,因此 number 不能从 101 改成 202。对于引用类型,变量保存的是引用值,因此 final 限制的是这个变量不能再指向其他对象,也不能改成 null。

变量指向的对象仍然可以修改,只要对象本身支持相应操作。例如,数组可以修改元素,ArrayList 可以添加元素:

final int[] numbers = {101};
numbers[0] = 202;
System.out.println(numbers[0]); // 202
// numbers = new int[] {303}; // 编译错误:给 numbers 重新赋值

final List<String> names = new ArrayList<>();
names.add("Lin");
System.out.println(names); // [Lin]
// names = new ArrayList<>(); // 编译错误:给 names 重新赋值

numbers[0] = 202 修改的是数组元素,names.add("Lin") 修改的是列表内容。numbers 和 names 保存的引用都没有变,所以这两种修改符合 final 的限制。final 修饰的是变量,不会让数组元素或集合内容也变成不可修改的。

6.2 浅拷贝​

数组的 clone() 做的是浅拷贝:新建一个数组,复制每个元素的值。元素是引用时,不会继续复制引用指向的对象。下面的两个数组就共享同一个 StringBuilder:

StringBuilder[] first = {new StringBuilder("A")};
StringBuilder[] second = first.clone();
second[0].append("B");
System.out.println(first[0]); // AB

first 和 second 指向两个不同的数组,但 first[0] 和 second[0] 指向同一个 StringBuilder。second[0].append("B") 修改了这个共享对象的内容,所以通过 first[0] 读到的也是 AB。

second = first.clone()first(原数组)[0]second(新数组)[0]StringBuilder"AB"数组是新的,元素指向的对象仍然共享

想让两份数据互不影响,就要用深拷贝,把里面的可变对象也复制一份。如果原来有多个引用指向同一个子对象,深拷贝时还要想好:复制出来的结构里,它们是继续共享同一个副本,还是各自一份。

7. 面试题卡片​

8. 参考资料​

来源:Coding 101 原文 · 免费阅读,引用请保留出处。内容使用说明