02_参数传递（值传递 引用传递）

一、参数传递的基本概念

方法参数传递是指在调用方法时，将实际参数（实参）的值传递给方法的形式参数（形参）的过程。Java 中参数传递的核心机制决定了方法内部对参数的修改是否会影响外部实参，这是理解方法交互的关键。
核心问题：当在方法内部修改形参时，外部的实参是否会发生变化？
答案取决于参数的数据类型（基本类型或引用类型），Java 中存在两种传递方式的表现：值传递和引用传递的表现。

二、值传递（基本数据类型）

2.1 定义与原理

值传递是指将实参的值的副本传递给形参。方法内部对形参的修改仅作用于副本，不会影响原始实参的值。
适用类型：所有基本数据类型（byte、short、int、long、float、double、char、boolean）。

2.2 执行流程

步骤解析：

1. 调用方法时，计算实参的值
2. 创建形参变量，并将实参的值复制到形参中（形参与实参是两个独立的变量）
3. 方法内部对形参的修改仅改变副本的值
4. 方法执行结束后，形参被销毁，实参的值保持不变

2.3 代码示例

public class ValuePassingDemo {
    public static void main(String[] args) {
        int num = 10; // 实参
        System.out.println("调用方法前：num = " + num); // 输出10
        
        changeValue(num); // 传递num的值（10）
        
        System.out.println("调用方法后：num = " + num); // 输出10（实参未变）
    }
    
    // 形参为基本类型int
    public static void changeValue(int a) {
        a = 20; // 修改形参的值（仅影响副本）
        System.out.println("方法内部：a = " + a); // 输出20
    }
}

输出结果：

调用方法前：num = 10
方法内部：a = 20
调用方法后：num = 10

2.4 特点总结

• 形参与实参占用不同的内存空间，是相互独立的变量
• 方法内部对形参的任何修改不会影响实参
• 传递的是 "值的副本"，本质是数据的复制

三、引用传递的表现（引用数据类型）

3.1 定义与原理

对于引用数据类型（如String、数组、对象等），Java 传递的是对象引用的副本（即对象在内存中的地址的副本）。这意味着形参和实参指向同一个对象，但引用本身是独立的副本。
表现特征：
方法内部通过形参修改对象的属性或内容时，会影响外部实参指向的对象（因指向同一内存）
方法内部将形参指向新对象时，不会影响外部实参（因引用副本的指向改变，不影响原始引用）

3.2 执行流程

步骤解析：

1. 调用方法时，实参是对象的引用（地址）
2. 创建形参变量，将实参的引用值复制给形参（形参与实参指向同一个对象）
3. 若方法内部通过形参修改对象的属性或内容，实参指向的对象会同步变化
4. 若方法内部将形参指向新对象（如a = new Object()），仅形参的引用改变，实参仍指向原对象
5. 方法执行结束后，形参被销毁，实参的引用和指向的对象状态根据步骤 3/4 决定

3.3 代码示例

示例 1：修改对象内容（影响实参）

public class ReferencePassingDemo1 {
    // 自定义类（引用类型）
    static class Person {
        String name;
        Person(String name) {
            this.name = name;
        }
    }
    
    public static void main(String[] args) {
        Person p = new Person("张三"); // 实参：指向"张三"的引用
        System.out.println("调用方法前：p.name = " + p.name); // 输出"张三"
        
        changeName(p); // 传递引用的副本
        
        System.out.println("调用方法后：p.name = " + p.name); // 输出"李四"（对象内容被修改）
    }
    
    // 形参为引用类型Person
    public static void changeName(Person person) {
        person.name = "李四"; // 修改对象的属性（影响原对象）
        System.out.println("方法内部：person.name = " + person.name); // 输出"李四"
    }
}

输出结果

调用方法前：p.name = 张三
方法内部：person.name = 李四
调用方法后：p.name = 李四

示例 2：修改引用指向（不影响实参）

public class ReferencePassingDemo2 {
    static class Person {
        String name;
        Person(String name) {
            this.name = name;
        }
    }
    
    public static void main(String[] args) {
        Person p = new Person("张三"); // 实参：指向"张三"的引用
        System.out.println("调用方法前：p.name = " + p.name); // 输出"张三"
        
        changeReference(p); // 传递引用的副本
        
        System.out.println("调用方法后：p.name = " + p.name); // 输出"张三"（实参指向未变）
    }
    
    public static void changeReference(Person person) {
        // 形参指向新对象（原对象不受影响）
        person = new Person("李四"); 
        System.out.println("方法内部：person.name = " + person.name); // 输出"李四"
    }
}

输出结果

调用方法前：p.name = 张三
方法内部：person.name = 李四
调用方法后：p.name = 张三

示例 3：数组（引用类型）的传递

public class ArrayPassingDemo {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3}; // 实参：数组引用
        System.out.println("调用方法前：arr[0] = " + arr[0]); // 输出1
        
        changeArray(arr);
        
        System.out.println("调用方法后：arr[0] = " + arr[0]); // 输出100（数组内容被修改）
    }
    
    public static void changeArray(int[] array) {
        array[0] = 100; // 修改数组元素（影响原数组）
        array = new int[]{4, 5, 6}; // 形参指向新数组（不影响实参）
    }
}

四、String 类型的特殊性

String是引用类型，但由于其不可变性（一旦创建，内容不可修改），表现出类似基本类型的传递特征。

4.1 原理分析

String对象的任何修改（如拼接、替换）都会创建新的String对象，而非修改原对象。因此，方法内部对String形参的修改不会影响外部实参。

4.2 代码示例

public class StringPassingDemo {
    public static void main(String[] args) {
        String str = "Hello"; // 实参：指向"Hello"的引用
        System.out.println("调用方法前：str = " + str); // 输出"Hello"
        
        changeString(str);
        
        System.out.println("调用方法后：str = " + str); // 输出"Hello"（未变）
    }
    
    public static void changeString(String s) {
        s = s + " World"; // 创建新String对象，形参指向新对象
        System.out.println("方法内部：s = " + s); // 输出"Hello World"
    }
}

输出结果：

调用方法前：str = Hello
方法内部：s = Hello World
调用方法后：str = Hello

五、值传递与引用传递的核心区别

传递类型	数据类型	传递内容	对实参的影响	典型示例
值传递	基本类型	实参值的副本	无影响（修改的是副本）	int、double
引用传递的表现	引用类型（非 String）	实参引用的副本（指向同一对象）	1. 修改对象内容：实参受影响 2. 修改引用指向：实参不受影响	Person对象、数组
特殊引用传递	String及包装类（Integer等）	引用的副本	因不可变性，修改形参不影响实参	String、Integer

Java 的本质：严格来说，Java 中只有值传递—— 基本类型传递值的副本，引用类型传递引用（地址）的副本。所谓 "引用传递的表现" 是引用类型值传递的特殊效果。

六、常见错误与理解误区

6.1 误区 1：引用类型的传递是 "引用传递"（严格意义）

• 错误观点："Java 中引用类型是引用传递，基本类型是值传递"。
• 正确理解：Java 中所有参数传递都是值传递，引用类型传递的是 "引用值的副本"，因指向同一对象而表现出类似引用传递的效果。

6.2 误区 2：修改形参引用一定会影响实参

错误示例：

public static void setNewObject(Person p) {
    p = new Person("李四"); // 形参指向新对象
}

// 调用后，实参仍指向原对象，因形参的引用修改不影响实参

6.3 误区 3：String 类型是基本类型

String是引用类型，但其不可变性导致修改形参时表现与基本类型一致，容易被误认为是基本类型。

七、最佳实践

1. 明确参数类型的影响：传递基本类型时无需担心实参被修改；传递引用类型时，需注意方法是否会修改对象内容。
2. 避免修改参数引用：方法内部尽量不将形参指向新对象（除非必要），减少代码误解。
3. 不可变对象优先：使用String、Integer等不可变类型作为参数，可避免方法内部意外修改对象内容，提高代码安全性。
4. 复制对象传递：若需传递引用类型且不希望原对象被修改，可传递对象的副本（如通过clone()方法）：

// 传递对象副本，避免原对象被修改
public static void process(Person p) {
    Person copy = new Person(p.name); // 创建副本
    // 修改copy，不影响原对象
}

八、总结

Java 的参数传递机制可概括为：

• 基本类型：值传递，传递值的副本，方法内修改不影响实参。
• 引用类型：值传递（传递引用的副本），方法内修改对象内容会影响实参，修改引用指向则不会。
• 特殊类型：String及包装类因不可变性，表现出类似基本类型的传递特征。

理解参数传递的本质，能帮助开发者避免因参数修改导致的逻辑错误，是编写可靠 Java 代码的基础。