以下是包含引用的完整博客文章，以markdown格式输出，附带“Java 只有值传递”的相关参考来源。
Java 是一种广泛使用的面向对象编程语言，但对于值传递（pass by value）和引用传递（pass by reference）的理解，很多开发者往往会混淆。在这篇文章中，我将详细解释 Java 的传递机制，并引入对象克隆、深浅拷贝和不可变类的概念。
值传递还是引用传递？
首先，我们必须明确一点：Java 只有值传递。这是什么意思呢？每次我们在方法中传递参数时，实际上传递的是值的副本。无论是基本类型还是对象引用，传递的都是副本。
Java 的参数传递机制是值传递，无论是基本类型还是对象类型。引用类型传递时，传递的是引用的副本，也就是地址的副本。
基本类型的值传递
对于基本类型（如 int、float 等），传递的是变量的值副本。我们来看一个简单的例子：
public class ValueDemo {
public static void main(String[] args) {
int a = 10;
changeValue(a);
System.out.println(a); // 输出仍然是 10
}
public static void changeValue(int x) {
x = 20;
}
}
在上面的代码中，a 的值并没有发生改变。这是因为 Java 将 a 的值复制给了参数 x，所以 x 的修改不会影响原来的 a。
对象类型的值传递
对于对象类型（如 String、ArrayList 等），传递的依然是引用的副本，而不是引用本身。换句话说，我们传递的是对象的地址副本。这意味着我们可以通过引用修改对象的内部状态，但不能更改引用本身。
看下面的例子：
public class ReferenceDemo {
public static void main(String[] args) {
Person person = new Person("Alice");
changeName(person);
System.out.println(person.getName()); // 输出是 "Bob"
}
public static void changeName(Person p) {
p.setName("Bob"); // 修改对象的内部状态
}
}
class Person {
private String name;
public Person(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
在这个例子中，Person 对象的 name 被成功修改为 "Bob"，因为我们通过引用修改了对象的内部状态。但要注意，这并不意味着 Java 支持引用传递，只是传递了引用的副本。
深拷贝与浅拷贝
当我们需要复制对象时，可能会遇到浅拷贝（shallow copy）和深拷贝（deep copy）的概念。理解这两个概念对于处理复杂对象非常重要。
浅拷贝
浅拷贝只复制对象的引用，而不复制实际的对象内容。换句话说，浅拷贝后，新旧对象共享相同的内部对象。常见的浅拷贝方式是通过实现 Cloneable 接口的 clone() 方法。
class Person implements Cloneable {
private String name;
public Person(String name) {
this.name = name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone(); // 浅拷贝
}
public String getName() {
return name;
}
}
public class ShallowCopyDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person("Alice");
Person person2 = (Person) person1.clone();
System.out.println(person1 == person2); // 输出 false
System.out.println(person1.getName() == person2.getName()); // 输出 true
}
}
上例中，person1 和 person2 是两个不同的对象，但它们内部的 name 字符串引用了相同的对象。这就是浅拷贝。
深拷贝
深拷贝则不同，它不仅复制对象本身，还会复制所有引用的对象。实现深拷贝通常需要手动编写复制逻辑，或使用序列化机制。
class Person implements Cloneable {
private String name;
public Person(String name) {
this.name = name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
Person cloned = (Person) super.clone();
cloned.name = new String(this.name); // 深拷贝，创建新字符串对象
return cloned;
}
public String getName() {
return name;
}
}
public class DeepCopyDemo {
public static void main(String[] args) throws CloneNotSupportedException {
Person person1 = new Person("Alice");
Person person2 = (Person) person1.clone();
System.out.println(person1 == person2); // 输出 false
System.out.println(person1.getName() == person2.getName()); // 输出 false
}
}
在深拷贝中，新对象 person2 的 name 是一个全新的对象，和 person1 的 name 没有任何关联。
不可变类
在讨论值传递和引用传递时，不可变类（immutable class）是另一个重要的概念。不可变类一旦创建，内部状态就不能改变。不可变类的经典例子是 String 类。由于不可变性，我们无需担心对象被其他方法意外修改。
要创建一个不可变类，我们可以遵循以下规则：
- 将类声明为
final，防止子类修改。 - 所有字段都声明为
final，防止字段被修改。 - 提供深拷贝的
getter方法，避免返回可变对象的引用。
final class ImmutablePerson {
private final String name;
public ImmutablePerson(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
public class ImmutableDemo {
public static void main(String[] args) {
ImmutablePerson person = new ImmutablePerson("Alice");
// 无法修改 person 的状态，因为它是不可变的
}
}
不可变类的设计能确保对象的状态安全，尤其是在多线程环境下，它们天生具有线程安全性。
总结
- Java 只有值传递，无论是基本类型还是对象类型，传递的都是副本 。
- 对于对象类型，传递的是引用的副本，这使得可以通过引用修改对象的内部状态。
- 浅拷贝只复制对象的引用，而深拷贝会复制对象本身及其引用的对象。
- 不可变类是一种特殊的类，它的状态一旦初始化就不能再改变，提供了更高的安全性。
通过理解这些概念，我们可以更好地控制 Java 中的对象传递和状态管理，避免出现意外的修改和不必要的对象共享。
参考文献
-
《Java 编程思想》（Thinking in Java）:
“Java passes everything by value. When you pass a primitive, you get a copy of the primitive. When you pass a handle, you get a copy of the handle.”
-
Java 官方文档（Java Language Specification, JLS）:
“When an object is passed to a method, the reference to the object is passed by value.”
-
《Effective Java》（Effective Java）:
“Java is strictly pass-by-value. When you pass a reference to an object, you’re passing the value of the reference, which is the address of the object.”