java方法参数值传递, 拷贝引用

最新推荐文章于 2024-09-27 00:45:01 发布

Blue_Bang

最新推荐文章于 2024-09-27 00:45:01 发布

阅读量126

点赞数 5

文章标签： java 后端

本文链接：https://blog.csdn.net/qq_39282921/article/details/141404644

版权

package com.blue.test;

import java.util.concurrent.*;

public class MyTest {
    public static void main(String[] args) {
        StringBuilder a = new StringBuilder("A");
        StringBuilder b = new StringBuilder("B");
        test(a,b);
        System.out.println(a+"."+b);
        b = a;
        System.out.println(a+"."+b);
        System.out.println("------------");
        Sun s1 = new Sun("A", 10);
        Sun s2 = new Sun("B", 20);
        test(s1, s2);
        System.out.println(s1+" || "+s2);
        s2 = s1;
        System.out.println(s1+" || "+s2);
    }

    public static void test(StringBuilder x, StringBuilder y) {
        x.append(y);
        y=x;
    }

    public static void test(Sun x, Sun y) {
        x.setName(y.getName()+"-new");
        y=x;
    }

    static class Sun{
        private String name;
        private int age;

        public Sun() {
        }

        public Sun(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public int getAge() {
            return age;
        }

        public void setAge(int age) {
            this.age = age;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        @Override
        public String toString() {
            return "Sun{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }
}

输出

AB.B	// 这个B是不是有大大的疑问, 应该是AB, 但却不是, 实际没有改变, 应该进入方法后,参数的是新的引用,指向同一个地址
AB.AB
------------
Sun{name='B-new', age=10} || Sun{name='B', age=20}
Sun{name='B-new', age=10} || Sun{name='B-new', age=10}

问题案例中AB.B的输出是否有大大的疑问?
怀疑应该是AB.AB, 但却不是, 实际没有改变, 应该进入方法后,参数的是新的引用,指向同一个地址, 方法内的y=x, 只是赋值了引用, 但实际的内存值没有改;

资料:
在Java中，方法参数的传递方式主要是值传递（Pass by Value）。这意味着当一个方法被调用时，实际参数的值会被复制一份传递给方法中的形参。这种机制确保了方法内部对参数的修改不会影响到实际参数的值。

具体来说，对于基本数据类型（如int、long等），Java采用的是值拷贝的方式进行传递。例如，在代码片段中：

public class Test {
    public static void main(String[] args) {
        int a = 5;
        fun(a);
        System.out.println (a); // 输出结果为5
    }

    private static void fun(int a) {
        a += 1;
    }
}

在这个例子中，fun方法接收到的是a的副本，因此a在fun方法中的增加操作不会影响到main方法中的a的值。

对于引用类型（如对象或数组），Java采用的是引用拷贝的方式进行传递。这意味着方法接收到的是对象引用的副本，而不是对象本身。因此，如果在方法中修改了这个引用指向的对象，那么实际参数也会受到影响。但是，如果在方法中直接修改引用本身（即改变引用变量指向的对象），则不会影响实际参数。

例如：

public class Test {
    public static void main(String[] args) {
        String str = "original";
        fun(str);
        System.out.println (str); // 输出仍然是"original"
    }

    private static void fun(String str) {
        str = "modified";
    }
}