Java 值传递与引用传递

以下是包含引用的完整博客文章，以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 类。由于不可变性，我们无需担心对象被其他方法意外修改。

要创建一个不可变类，我们可以遵循以下规则：

1. 将类声明为 final，防止子类修改。
2. 所有字段都声明为 final，防止字段被修改。
3. 提供深拷贝的 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 中的对象传递和状态管理，避免出现意外的修改和不必要的对象共享。

---

参考文献

1. 《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.”

2. Java 官方文档（Java Language Specification, JLS）:

   “When an object is passed to a method, the reference to the object is passed by value.”

3. 《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.”

原文地址：https://blog.csdn.net/problc/article/details/142307686

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！