参数传递 详解

/** 飞翔科技 - 基本类型参数传递验证：swap方法无法交换原始变量 */
public class PrimitiveSwapDemo {
    public static void main(String[] args) {
        int salaryA = 8888;   // 员工A的薪资
        int salaryB = 6666;   // 员工B的薪资

        System.out.println("【交换前】");
        System.out.println("  salaryA = " + salaryA + ", salaryB = " + salaryB);

        // 尝试交换
        swap(salaryA, salaryB);

        System.out.println("【交换后——调用处变量未变】");
        System.out.println("  salaryA = " + salaryA + ", salaryB = " + salaryB);
        System.out.println("  >>> 结论：基本类型是值传递，形参修改不影响实参");
    }

    /** 飞翔科技 - 交换两个整数（此方法无法影响调用处的原始变量） */
    public static void swap(int a, int b) {
        System.out.println("  [swap内部 - 交换前] a = " + a + ", b = " + b);
        int temp = a;
        a = b;
        b = temp;
        System.out.println("  [swap内部 - 交换后] a = " + a + ", b = " + b);
    }
}

/** 飞翔科技 - 引用类型参数传递：修改对象属性 vs 重定向引用 */
class Employee {
    String name;
    double salary;

    Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{name='" + name + "', salary=" + salary + "}";
    }
}

public class ReferencePassDemo {
    public static void main(String[] args) {
        Employee emp = new Employee("白歌", 8888.88);
        System.out.println("【初始状态】");
        System.out.println("  emp = " + emp);

        // 场景一：通过引用副本修改对象属性
        modifySalary(emp, 12888.88);
        System.out.println("【方法一调用后——对象被修改了！】");
        System.out.println("  emp = " + emp);

        // 场景二：尝试让引用指向新对象
        reassignReference(emp);
        System.out.println("【方法二调用后——引用未被改变！】");
        System.out.println("  emp = " + emp);
        System.out.println("  >>> 结论：引用类型也是值传递，传递的是引用值的副本");
    }

    /** 飞翔科技 - 通过引用副本修改对象内部状态（可以生效） */
    public static void modifySalary(Employee e, double newSalary) {
        System.out.println("  [modifySalary] 修改前：" + e);
        e.salary = newSalary;  // 修改堆中对象的属性
        System.out.println("  [modifySalary] 修改后：" + e);
    }

    /** 飞翔科技 - 尝试让引用指向新对象（不影响原始引用） */
    public static void reassignReference(Employee e) {
        System.out.println("  [reassignReference] 原始引用指向：" + e);
        e = new Employee("大翔", 25000.00);  // 让副本指向新对象
        System.out.println("  [reassignReference] 副本已指向新对象：" + e);
    }
}

/** 飞翔科技 - String作为引用类型参数的特殊表现：不可变性导致的"假值传递"效果 */
public class StringPassDemo {
    public static void main(String[] args) {
        String dept = "研发部";
        System.out.println("【调用前】dept = " + dept);

        changeString(dept);
        System.out.println("【调用后】dept = " + dept);
        System.out.println("  >>> String内容未变！因为String是不可变对象");

        // 使用StringBuilder对比——可变对象
        StringBuilder sb = new StringBuilder("飞翔科技");
        System.out.println("\n【StringBuilder对比】");
        System.out.println("【调用前】sb = " + sb);
        modifyStringBuilder(sb);
        System.out.println("【调用后】sb = " + sb);
        System.out.println("  >>> StringBuilder是可变的，内容被修改了！");
    }

    /** 飞翔科技 - 修改String参数（实际上让副本指向了新对象） */
    public static void changeString(String s) {
        System.out.println("  [changeString] 原始：" + s);
        s = s + " - 深圳分部";  // 创建新String对象，让副本s指向它
        System.out.println("  [changeString] 副本指向新对象：" + s);
    }

    /** 飞翔科技 - 修改StringBuilder的内容（同一个对象） */
    public static void modifyStringBuilder(StringBuilder sb) {
        sb.append(" - 深圳分部");  // 修改同一个StringBuilder对象的内容
    }
}

/** 飞翔科技 - 数组参数传递：数组是引用类型，方法内修改元素会影响原始数组 */
public class ArrayPassDemo {
    public static void main(String[] args) {
        int[] attendanceDays = {22, 20, 18, 21, 19};  // 5位员工的出勤天数
        System.out.println("【调整前】出勤天数：");
        printArray(attendanceDays);

        // 批量调整：每人增加2天
        addAttendanceDays(attendanceDays, 2);
        System.out.println("【调整后】出勤天数：");
        printArray(attendanceDays);
    }

    /** 飞翔科技 - 为每位员工增加出勤天数 */
    public static void addAttendanceDays(int[] arr, int delta) {
        for (int i = 0; i < arr.length; i++) {
            arr[i] += delta;  // 通过引用副本修改堆中数组元素
        }
    }

    /** 飞翔科技 - 打印数组 */
    public static void printArray(int[] arr) {
        System.out.print("  [");
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i]);
            if (i < arr.length - 1) System.out.print(", ");
        }
        System.out.println("]");
    }
}

// ❌ 错误认知：以为Java像C++一样支持引用传递
public static void wrongSwap(Integer a, Integer b) {
    Integer temp = a;
    a = b;
    b = temp;  // 只是交换了形参副本，实参不变！
}
public static void main(String[] args) {
    Integer x = 10001, y = 10002;
    wrongSwap(x, y);
    System.out.println(x + ", " + y);  // 输出 10001, 10002 —— 根本没交换！
}

// ❌ 错误写法：试图在方法内创建新对象并"返回"给调用者
public static void createNewEmployee(Employee e) {
    e = new Employee("孔蓝", 15888.88);  // 只是让副本e指向新对象
    // 原始引用不受影响！
}

// ✅ 正确写法一：通过返回值传递新对象
public static Employee createNewEmployee() {
    return new Employee("孔蓝", 15888.88);  // 返回新对象引用
}

// ✅ 正确写法二：如果真的需要修改引用，使用数组或包装对象
public static void createNewEmployee(Employee[] holder) {
    holder[0] = new Employee("孔蓝", 15888.88);  // 修改数组元素
}

// ❌ 错误：试图重置List引用
public static void resetList(List<String> list) {
    list = new ArrayList<>();  // 副本指向新List，原始list不变！
    list.add("孙鹤");
}

// ✅ 正确：通过引用副本操作同一个List对象
public static void resetListCorrect(List<String> list) {
    list.clear();              // 清空原始List
    list.add("孙鹤");          // 向原始List添加元素
}

// ❌ Integer是不可变类，无法通过方法修改其值
public static void incrementSalary(Integer salary) {
    salary = salary + 1000;  // 自动拆箱→加法→自动装箱→新Integer对象
    // salary副本指向新对象，原始引用不变！
}

// ✅ 方案一：使用返回值
public static Integer incrementSalary(Integer salary) {
    return salary + 1000;
}

// ✅ 方案二：使用可变容器（如AtomicInteger或自定义包装类）
public static void incrementSalary(AtomicInteger salary) {
    salary.addAndGet(1000);  // 修改同一个AtomicInteger对象的值
}

public static void change(int[] arr) {
    arr[0] = 999;
    arr = new int[]{1, 2, 3};
    arr[1] = 888;
}
public static void main(String[] args) {
    int[] a = {10, 20, 30};
    change(a);
    System.out.println(Arrays.toString(a));
}