方法的参数传递

理解Java参数传递机制是掌握方法的关键。

值传递概念

Java只有值传递

Java中所有参数传递都是值传递（传递副本）。

// 值传递：传递数据的副本
// 1. 基本类型：传递值的副本
// 2. 引用类型：传递引用的副本（地址的副本）

基本类型参数传递

传递值副本

public void changeValue(int num) {
    num = 100;  // 修改副本
}

int x = 10;
changeValue(x);
System.out.println(x);  // 10（原值不变）

传递过程示意

调用：changeValue(x)
         ↓
传递：x的值副本10 → num
         ↓
修改：num = 100（副本被修改）
         ↓
结果：x仍是10（原值未受影响）

各种基本类型

public void modify(int a, double b, boolean c) {
    a = 100;
    b = 99.9;
    c = true;
    // 修改的都是副本
}

int i = 1;
double d = 1.1;
boolean flag = false;

modify(i, d, flag);

System.out.println(i);      // 1（不变）
System.out.println(d);      // 1.1（不变）
System.out.println(flag);   // false（不变）

引用类型参数传递

传递引用副本

引用类型传递的是引用（地址）的副本，指向同一对象。

public void changeArray(int[] arr) {
    arr[0] = 100;  // 通过引用修改数组内容
}

int[] nums = {1, 2, 3};
changeArray(nums);
System.out.println(nums[0]);  // 100（原数组被修改）

传递过程示意

调用：changeArray(nums)
         ↓
传递：nums引用副本 → arr（指向同一数组）
         ↓
修改：arr[0] = 100（通过引用修改数组内容）
         ↓
结果：nums[0]变为100（同一数组）

对象参数传递

public class Student {
    String name;
    
    public Student(String name) {
        this.name = name;
    }
}

public void changeName(Student s) {
    s.name = "新名字";  // 通过引用修改对象属性
}

Student stu = new Student("原名");
changeName(stu);
System.out.println(stu.name);  // "新名字"（原对象被修改）

引用重新赋值不影响原引用

public void reassign(Student s) {
    s = new Student("其他人");  // 引用副本指向新对象
    // 原引用不受影响
}

Student stu = new Student("张三");
reassign(stu);
System.out.println(stu.name);  // "张三"（原引用不变）

基本类型与引用类型对比

传递行为对比

// 基本类型：传递值副本
public void test1(int num) {
    num = 100;  // 不影响原变量
}

// 引用类型：修改对象内容
public void test2(int[] arr) {
    arr[0] = 100;  // 影响原数组
}

// 引用类型：重新赋值
public void test3(int[] arr) {
    arr = new int[5];  // 不影响原引用
}

数组参数示例

修改数组元素

public void doubleArray(int[] arr) {
    for (int i = 0; i < arr.length; i++) {
        arr[i] = arr[i] * 2;  // 修改原数组
    }
}

int[] nums = {1, 2, 3};
doubleArray(nums);
// nums变为：{2, 4, 6}

数组作为参数遍历

public void printArray(int[] arr) {
    for (int num : arr) {
        System.out.println(num);
    }
}

int[] nums = {1, 2, 3};
printArray(nums);  // 输出1, 2, 3

数组作为参数查找

public int findMax(int[] arr) {
    int max = arr[0];
    for (int i = 1; i < arr.length; i++) {
        if (arr[i] > max) {
            max = arr[i];
        }
    }
    return max;
}

int[] nums = {5, 2, 8, 1, 9};
int max = findMax(nums);  // 9

对象参数示例

修改对象属性

public class Person {
    String name;
    int age;
}

public void updatePerson(Person p, String name, int age) {
    p.name = name;  // 修改原对象
    p.age = age;
}

Person person = new Person();
updatePerson(person, "张三", 25);
System.out.println(person.name);  // "张三"
System.out.println(person.age);   // 25

对象方法调用

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

public void useCalculator(Calculator calc) {
    int result = calc.add(5, 3);  // 通过引用调用方法
    System.out.println(result);
}

Calculator myCalc = new Calculator();
useCalculator(myCalc);  // 输出：8

String参数特殊性

String不可变

String作为参数，修改不影响原字符串。

public void changeString(String str) {
    str = "新字符串";  // 引用副本指向新对象
    // 原字符串不变（String不可变）
}

String s = "原字符串";
changeString(s);
System.out.println(s);  // "原字符串"（不变）

String参数特点

• String是引用类型，但不可变
• 方法内重新赋值不影响原引用
• 方法内调用方法（如substring）产生新字符串

public void process(String str) {
    str = str.toUpperCase();  // 返回新字符串，原不变
}

String s = "hello";
process(s);
System.out.println(s);  // "hello"（不变）

多参数传递

多个参数

public int calculate(int a, int b, String op) {
    if ("add".equals(op)) {
        return a + b;
    } else if ("sub".equals(op)) {
        return a - b;
    }
    return 0;
}

int result = calculate(10, 5, "add");  // 15

可变参数

public int sum(int... nums) {
    int total = 0;
    for (int num : nums) {
        total += num;
    }
    return total;
}

// 调用方式灵活
int r1 = sum(1, 2, 3);       // 6
int r2 = sum(1, 2, 3, 4, 5); // 15
int r3 = sum();              // 0

// 也可传数组
int[] arr = {1, 2, 3};
int r4 = sum(arr);           // 6

参数传递误区

误区1：Java有引用传递

// Java只有值传递，没有引用传递
// 引用类型传递的是引用的副本，不是引用本身

public void reassign(int[] arr) {
    arr = new int[5];  // 引用副本指向新数组
    // 原引用不变
}

误区2：基本类型传递会改变原值

// 基本类型传递值副本，不会改变原值

public void modify(int x) {
    x = 100;
}

int a = 10;
modify(a);
// a仍是10

要点总结

• Java参数传递都是值传递
• 基本类型：传递值副本，不影响原变量
• 引用类型：传递引用副本（地址副本）
• 引用类型修改对象内容会影响原对象
• 引用类型重新赋值不影响原引用
• String不可变，传递后修改不影响原字符串
• 数组是引用类型，修改元素影响原数组
• 可变参数用...表示，接受任意数量参数
• 可变参数本质是数组
• 方法内无法改变原引用指向