java中方法的参数传递机制

　问：当一个对象被当作参数传递到一个方法后，此方法可改变这个对象的属性，并可返回变化后的结果，那么这里到底是值传递还是引用传递? 

　　答: 是值传递。Java参数，不管是原始类型还是引用类型，传递的都是副本。当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本(存放的是参数的地址)。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。

　　Java参数，不管是原始类型还是引用类型，传递的都是副本(有另外一种说法是传值，但是说传副本更好理解吧，传值通常是相对传址而言)。

　　1) 参数是原始类型，传过来的是参数的一个副本，也就是这个原始参数的值。如果在函数中改变了副本的值不会改变原始的值.

　　2) 参数是引用类型，传过来的是引用参数的副本，存放的是参数地址。如果在函数中没有改变这个副本的地址，而是改变了地址中的对象的值，那么在函数内的改变会影响到传入的参数。如果在函数中改变了副本的地址，如new一个，那么副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。

基本类型参数传递---不改变值

public class Test {
    public static void main(String[] args) {
        int a = 10;
        System.out.println(a); // 输出：10

        changeValue(a);
        System.out.println(a); // 输出：10
    }

    public static void changeValue(int x) {
        x = 20;
    }
}

      

引用类型参数传递---改变值(不new一个对象情况下)

public class Test {
    public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println(Arrays.toString(arr)); // 输出：[1, 2, 3]

        changeArray(arr);
        System.out.println(Arrays.toString(arr)); // 输出：[4, 5, 6]
    }

    public static void changeArray(int[] array) {
        for (int i = 0; i < array.length; i++) {
            array[i] += 3;
        }
    }
}

引用类型参数传递---改变值(new一个对象情况下)  --传过来的是引用参数的副本，存放的是参数地址, 副本就指向了一个新的地址，此时传入的参数还是指向原来的地址，所以不会改变参数的值。

public static void main(String[] args) {
        int[] arr = {1, 2, 3};
        System.out.println(Arrays.toString(arr)); // 输出：[1, 2, 3]

        changeArray(arr);
        System.out.println(Arrays.toString(arr)); // 输出：[1, 2, 3]
    }

    public static void changeArray(int[] array) {
        array =new int[]{1, 2, 3};
        for (int i = 0; i < array.length; i++) {
            array[i] += 3;
        }
    }

补充: 在Java中，String Boolean  Short等是一个引用类型，但是在作为参数传递的时候表现出来的却是基本类型的特性,  因为它们都是不可变的对象（immutable object）。这意味着一旦创建了这些对象，就不能修改它们的值。当将这些对象作为参数传递给方法时，实际上传递的是对象引用的副本，而不是对象本身。因此，如果在方法中修改这些对象的属性，实际上是创建了一个新的对象，并将引用指向这个新的对象，原始对象并没有改变。

 //String类型 不管有没有new对象都不会改变原有值

public static void main(String[] args){
    String originalStr = "original";
    System.out.println("调用simpleChangeString前: " + originalStr);
    simpleChangeString(originalStr);
    System.out.println("调用simpleChangeString后: " + originalStr);

    System.out.println("---------------------------------------------------");

    String originalStr1 = new String("original");
    System.out.println("调用changeNewString前: " + originalStr1);
    changeNewString(originalStr1);
    System.out.println("调用changeNewString后: " + originalStr1);
}

public static void simpleChangeString(String original) {
    original = original + " is changed!";
    System.out.println("调用simpleChangeString中: " + original);
}

public static void changeNewString(String original) {
    original = new String(original + " is changed!");
    System.out.println("调用changeNewString中: " + original);
}

//StringBuffer是引用类型, 和string不同
public class Test {

    public static void main(String[] args){
        StringBuffer s =  new StringBuffer("hello");
        StringBuffer s2 = new StringBuffer("world");
        test(s,s2);
        System.out.println("-----------------3");
        System.out.println(s); //hi welcome
        System.out.println(s2); //hello welcome
    }

    private static void test(StringBuffer s, StringBuffer s2) {
        System.out.println(s); //hello
        System.out.println(s2); //world
        System.out.println("-----------------1");
        s2=s;//s2指向了hello
        s=new StringBuffer("hi");
        System.out.println(s); //hi
        System.out.println(s2); ///hello
        System.out.println("-----------------2");
        s.append("welcome");
        s2.append("welcome");
    }

}

-------------------------------------------------------------原理--------------------------------------------------------------

无论是什么语言，要讨论参数传递方式，就得从内存模型说起，主要是我个人觉得从内存模型来说参数传递更为直观一些。闲言少叙，下面我们就通过内存模型的方式来讨论一下Java中的参数传递。

内存模型涉及到两种类型的内存：栈内存(stack)和堆内存(heap)。基本类型作为参数传递时，传递的是这个值的拷贝。无论你怎么改变这个拷贝，原值是不会改变的。看下边的一段代码，然后结合内存模型来说明问题：

public class ParameterTransfer {

     public static void main(String[] args) {

        int num = 30;

        System.out.println("调用add方法前num=" + num);

        add(num);

        System.out.println("调用add方法后num=" + num);

     }

  

     public static void add(int param) {

          param = 100;

     }

}    

 

        //无论你在add()方法中怎么改变参数param的值，原值num都不会改变。

        调用add方法前num=30

        调用add方法后num=30     

基本类型参数的传递方式原理:  当执行了int num = 30;这句代码后，程序在栈内存中开辟了一块地址为AD8500的内存，里边放的值是30，内存模型如下图：

                    
　　执行到add()方法时，程序在栈内存中又开辟了一块地址为AD8600的内存，将num的值30传递进来，此时这块内存里边放的值是30，执行param = 100;后，AD8600中的值变成了100,add()方法执行完后,num变量随之消失。内存模型如下图：   
                 

　　地址AD8600中用于存放param的值，和存放num的内存没有任何关系，无论你怎么改变param的值，实际改变的是地址为AD8600的内存中的值，而AD8500中的值并未改变，所以num的值也就没有改变。
　　

对象作为参数传递: 

public class ParameterTransfer{

    public static void main(String[] args){
        String[] array=new String[]{"huixin"};
        System.out.println("调用reset方法前array中的第0个元素的值是:" + array[0]);
        reset(array);
        System.out.println("调用reset方法后array中的第0个元素的值是:" +  array[0]);
    }

    private static void reset(String[] param) {
        param[0] = "hello, world!";
    }

}

运行的结果如下：

调用reset方法前array中的第0个元素的值是:huixin
调用reset方法后array中的第0个元素的值是:hello, world!

当对象作为参数传递时，传递的是对象的引用，也就是对象的地址。

       

　　当程序执行了String[] array = new String[] {"huixin"}后，程序在栈内存中开辟了一块地址编号为AD9500内存空间，用于存放array[0]的引用地址，里边放的值是堆内存中的一个地址，示例中的值为BE2500，可以理解为有一个指针指向了堆内存中的编号为BE2500的地址。堆内存中编号为BE2500的这个地址中存放的才是array[0]的值：huixin。

　　当程序进入reset方法后，将array的值，也就是对象的引用BE2500传了进来。这时，程序在栈内存中又开辟了一块编号为AD9600的内存空间，里边放的值是传递过来的值，即AD9600。可以理解为栈内存中的编号为AD9600的内存中有一个指针，也指向了堆内存中编号为BE2500的内存地址，如图所示：

       

　　这样一来，栈内存AD9500和AD9600(即array[0]和param的值)都指向了编号为BE2500的堆内存。

　　在reset方法中将param的值修改为hello, world!后，内存模型如下图所示：

       

　　改变对象param的值实际上是改变param这个栈内存所指向的堆内存中的值。param这个对象在栈内存中的地址是AD9600，里边存放的值是BE2500，所以堆内存BE2500中的值就变成了hello,world!。程序放回main方法之后，堆内存BE2500中的值仍然为hello,world!，main方法中array[0]的值时，从栈内存中找到array[0]的值是BE2500，然后去堆内存中找编号为BE2500的内存，里边的值是hello,world!。所以main方法中打印出来的值就变成了hello,world!

　　

小结：

　　无论是基本类型作为参数传递，还是对象作为参数传递，实际上传递的都是值，只是值的的形式不用而已。第一个示例中用基本类型作为参数传递时，将栈内存中的值30传递到了add方法中。第二个示例中用对象作为参数传递时，将栈内存中的值BE2500传递到了reset方法中。当用对象作为参数传递时，真正的值是放在堆内存中的，传递的是栈内存中的值，而栈内存中存放的是堆内存的地址，所以传递的就是堆内存的地址。这就是它们的区别。

京东笔试真题引用问题: 

//在上面的代码中，我们首先创建了一个长度为 1 的 Person 数组，并将其第一个元素初始化为名为 "张三" 的 Person 对象。
//然后，我们将 persons[0] 赋值给 person 变量，这样 person 将持有对 persons[0] 所引用的对象的引用。此时，person 和 persons[0] 引用的是同一个 Person 对象。
//接着，我们将 persons[0] 重新赋值为名为 "李四" 的 Person 对象，也就是将 persons[0] 的引用指向了另一个 Person 对象。此时，persons[0] 引用的是新的 Person 对象，而 person 仍然引用原来的 Person 对象。
//所以，最终输出的结果是 "张三"，说明 person 引用的是原来的 Person 对象，而不是被重新赋值的 Person 对象。这是由于 Java 中的数组赋值实际上传递的是数组元素的引用，而不是数组本身的引用，也就是说，在将 persons[0] 赋值给 person 之后，person 持有了对原有 Person 对象的引用，即使修改了 persons[0] 的引用，person 引用变量仍然指向原来的对象。
//因此，这里并没有值传递问题，而是关于引用的使用和理解问题。
public class Test {

    public static void main(String[] args) {
        Person[] persons = new Person[1];
        persons[0] = new Person("张三");

        Person person = persons[0];//此时获取的是上面的对象引用
        persons[0] = new Person("李四");//变量指定新的对象引用不会影响上面的对象
        System.out.println(person); //输出:  Person{name='张三'}
    }

    static class Person {

        private String name;

        public Person(String name) {
            this.name = name;
        }

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

}

public static void main(String[] args) {
    int[] arr = new int[]{1,2};
    int[] arr1 = new int[]{3,3};

    arr1=arr; //两个变量指向了同一个对象

    System.err.println(Arrays.toString(arr1));  //[1, 2]
    arr[0]=2;
    System.err.println(Arrays.toString(arr1)); //[2, 2]

}

转载至:  java中方法的参数传递机制 - Entropy_lxl - 博客园