Java中函数参数的传递是值传递

我会带着你远行 2022-08-08 16:45 215阅读 0赞

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  什么是值传递?什么是引用传递?  
2.    
3.  值传递是将要传递的值作为一副本传递.如   
4.  **int** i=4;  
5.  **int** j=i;  
6.  这里相当于把14复制了一个副本给j,结果是i=4,j=4

引用传递,传递的是引用对象的内存地址   
int \*p,\*p1;   
int j=5; \*p=j; //这里是把j在内存当中的地址赋给了指针p   
p1=p; //这里是把指针p中保存的地址(就是j的地址)赋给了指针p1   
j=4; //这里改变j的值 输出结果是 j=4 , \*p=4 , \*p1=4 //因为p和p1指向的都是j 所以他们的值随j值改变   
(以上说明和代码来自http://zhidao.baidu.com/question/31191252.html)

Java中函数参数的传递是值传递还是引用传递？   
  
Java中参数传递时传递到函数中的参数都是原变量的一份拷贝，对于非类类型如int，float等，这份拷贝自然和原变量脱离了关系，这不难理解；  
而对于类的实例而言，这份拷贝恰巧是实例引用 (地址)的拷贝 ，它（参数）指向的实例地址和原实例引用指向的实例地址都是一样的，因此对参数的修改有时也会影响到实例本身，故此造成了Java传递类实例是传递的引用即地址的假象，如下面例子中的changeMemberField函数， 但是我们把参数指向的地址改到别的实例上时，如changeMember函数，我们会发现参数和原实例引用再也不会发生关系了 ，这里证明Java中参数传递是完完全全是传值而不是传址。  
  
例子代码：

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** com.sitinspring;  
2.    
3.  **public** **class** ChangeClass\{  
4.      **public** **void** changeInt(**int** i)\{  
5.          i=5;  
6.      \}  
7.        
8.      **public** **void** changeLong(**long** i)\{  
9.          i=555;  
10.     \}  
11.       
12.     **public** **void** changeString(String str)\{  
13.         str="5555";                //传进来的地址的拷贝，修改了拷贝地址的值，原来的引用并无改变
14.     \}  
15.       
16.     **public** **void** changeMember(Member member)\{  
17.         member=**new** Member("Cindy",35);//传进来的地址的拷贝，修改了拷贝地址的值，原来的引用并无改变
18.     \}  
19.       
20.     **public** **void** changeMemberField(Member member)\{  
21.         member.setAge(20);  
22.         member.setName("Andy");  
23.     \}  
24.       
25.     **public** **static** **void** main(String\[\] args)\{  
26.         ChangeClass changeClass=**new** ChangeClass();  
27.           
28.         **int** intValue=10;  
29.         changeClass.changeInt(intValue);  
30.         System.out.println(intValue);  
31.           
32.         **long** longValue=10;  
33.         changeClass.changeLong(longValue);  
34.         System.out.println(longValue);  
35.           
36.         String stringValue="1234";  
37.         changeClass.changeString(stringValue);  
38.         System.out.println(stringValue);          
39.           
40.         Member member2=**new** Member("Douglas",45);  
41.         changeClass.changeMember(member2);  
42.         System.out.println(member2);  
43.           
44.         Member member=**new** Member("Bill",25);  
45.         changeClass.changeMemberField(member);  
46.         System.out.println(member);  
47.     \}  
48. \}

**\[java\]**  [view plain][] [copy][view plain] [print][view plain] [?][view plain]

1.  **package** com.sitinspring;  
2.    
3.  **public** **class** Member\{  
4.      **private** String name;  
5.      **private** **int** age;  
6.        
7.      **public** Member(String name,**int** age)\{  
8.          **this**.age=age;  
9.          **this**.name=name;  
10.     \}  
11.       
12.     **public** String toString()\{  
13.         **return** "Member name="\+name+" age="\+age;  
14.     \}  
15.   
16.     **public** **int** getAge() \{  
17.         **return** age;  
18.     \}  
19.   
20.     **public** **void** setAge(**int** age) \{  
21.         **this**.age = age;  
22.     \}  
23.   
24.     **public** String getName() \{  
25.         **return** name;  
26.     \}  
27.   
28.     **public** **void** setName(String name) \{  
29.         **this**.name = name;  
30.     \}      
31. \}

输出 ：

10  
10  
1234  
Member name=Douglas age=45  
Member name=Andy age=20

**解释**：  
第一个输出10是因为int是基本类型,传递的参数是intValue的拷贝,对拷贝的修改对原值intValue没有影响.  
第一个输出10和上面是一个道理.  
第三个输出1234.由于String是类类型, str是stringValue的地址拷贝,参数str指向的地址和stringValue的一致,但在函数changeString 中,由于String的特殊性, str=“5555”和str=new String(“5555”)是等价的, str（拷贝）指向了新的”5555”所在的地址,此句后str就与原来的stringValue彻底脱离了联系.  
第四个输出Member?name=Douglas?age=45的道理和上面相同.  
第五个输出Member?name=Andy?age=20是因为changeMemberField函数中修改了参数member 的值,也就是修改member指向实例的值,而这个实例正是member指向的值,因此member就变成了name=Andy 且age=20.  
  
**结论**  
  
Java中参数传递的都是值,对应基本类型,传递的是原值的拷贝;对于类类型,传递的是引用即地址的拷贝.  
对于函数对参数的改变是否会影响原值的问题:值类型自然不会影响到原值.而对于类类型要看改变的是参数的地址还是值,如果是前者,参数和原引用指向了不同的地址,它们自然脱离了关系;如果是后者,修改的实例就是原引用指向的实例,这当然对原值进行了修改.

另一个例子：

/**
     * @description Java中没有引用传递只有值传递
     * 
     * @author Alexia
     * @date 2013-10-16
     * 
     */
    class Person {
    
        private String name;
    
        private String sex;
    
        public Person(String x, String y) {
            this.name = x;
            this.sex = y;
        }
    
        // 重写toString()方法，方便输出
        public String toString() {
    
            return name + " " + sex;
        }
    
        // 交换对象引用
        public static void swapObject(Person p1, Person p2) {//传递的是地址的拷贝，改变参数的地址，不起作用
            Person tmp = p1;
            p1 = p2;
            p2 = tmp;
        }
    
        // 交换基本类型
        public static void swapInt(int a, int b) {
            int tmp = a;
            a = b;
            b = tmp;
        }
    
        // 交换对象数组
        public static void swapObjectArray(Person[] p1, Person[] p2) {
         //传递的是地址的拷贝，改变参数的地址，不起作用
    
            Person[] tmp = p1;
            p1 = p2;
            p2 = tmp;
        }
    
        // 交换基本类型数组
        public static void swapIntArray(int[] x, int[] y) { //传递的是地址的拷贝，改变参数的地址，不起作用
    
            int[] tmp = x;
            x = y;
            y = tmp;
        }
    
        // 改变对象数组中的内容，起作用
        public static void changeObjectArray(Person[] p1, Person[] p2) {
            Person tmp = p1[1];
            p1[1] = p2[1];
            p2[1] = tmp;
            
            // 再将p1[1]修改
            Person p = new Person("wjl", "male");
            p1[1] = p;
        }
    
        // 改变基本类型数组中的内容，起作用
        public static void changeIntArray(int[] x, int[] y) {
            int tmp = x[1];
            x[1] = y[1];
            y[1] = tmp;
    
            x[1] = 5;
        }
    }
    
    public class ByValueTest {
    
        public static void main(String[] args) {
    
            // 建立并构造两个对象
            Person p1 = new Person("Alexia", "female");
            Person p2 = new Person("Edward", "male");
    
            System.out.println("对象交换前：p1 = " + p1.toString());
            System.out.println("对象交换前：p2 = " + p2.toString());
            
            // 交换p1对象和p2对象
            Person.swapObject(p1, p2);
            // 从交换结果中看出，实际对象并未交换
            System.out.println("\n对象交换后：p1 = " + p1.toString());
            System.out.println("对象交换后：p2 = " + p2.toString());
    
            // 建立两个对象数组
            Person[] arraya = new Person[2];
            Person[] arrayb = new Person[2];
    
            // 分别构造数组对象
            arraya[0] = new Person("Alexia", "female");
            arraya[1] = new Person("Edward", "male");
            arrayb[0] = new Person("jmwang", "female");
            arrayb[1] = new Person("hwu", "male");
    
            System.out.println('\n' + "对象数组交换前：arraya[0] = "
                    + arraya[0].toString() + ", arraya[1] = "
                    + arraya[1].toString());
            System.out.println("对象数组交换前：arrayb[0] = "
                    + arrayb[0].toString() + ", arrayb[1] = "
                    + arrayb[1].toString());
            
            // 交换这两个对象数组
            Person.swapObjectArray(arraya, arrayb);
            System.out.println('\n' + "对象数组交换后：arraya[0] = "
                    + arraya[0].toString() + ", arraya[1] = "
                    + arraya[1].toString());
            System.out.println("对象数组交换后：arrayb[0] = "
                    + arrayb[0].toString() + ", arrayb[1] = "
                    + arrayb[1].toString());
    
            // 建立两个普通数组
            int[] a = new int[2];
            int[] b = new int[2];
    
            // 给数组个元素赋值
            for (int i = 0; i < a.length; i++) {
                a[i] = i;
                b[i] = i + 1;
            }
    
            System.out.println('\n' + "基本类型数组交换前：a[0] = " + a[0] + ", a[1] = " + a[1]);
            System.out.println("基本类型数组交换前：b[0] = " + b[0] + ", b[1] = " + b[1]);
    
            // 交换两个基本类型数组
            Person.swapIntArray(a, b);
            System.out.println('\n' + "基本类型数组交换后：a[0] = " + a[0] + ", a[1] = " + a[1]);
            System.out.println("基本类型数组交换后：b[0] = " + b[0] + ", b[1] = " + b[1]);
            
            // 改变对象数组的内容
            Person.changeObjectArray(arraya, arrayb);
            System.out.println('\n' + "对象数组内容交换并改变后：arraya[1] = " + arraya[1].toString());
            System.out.println("对象数组内容交换并改变后：arrayb[1] = " + arrayb[1].toString());
            
            // 改变基本类型数组的内容
            Person.changeIntArray(a, b);
            System.out.println('\n' + "基本类型数组内容交换并改变后：a[1] = " + a[1]);
            System.out.println("基本类型数组内容交换并改变后：b[1] = " + b[1]);
        }
    }

![复制代码][copycode.gif]

程序有些啰嗦，但能反映问题，该程序运行结果为：

![复制代码][copycode.gif]

对象交换前：p1 = Alexia female
    对象交换前：p2 = Edward male
    
    对象交换后：p1 = Alexia female
    对象交换后：p2 = Edward male
    
    对象数组交换前：arraya[0] = Alexia female, arraya[1] = Edward male
    对象数组交换前：arrayb[0] = jmwang female, arrayb[1] = hwu male
    
    对象数组交换后：arraya[0] = Alexia female, arraya[1] = Edward male
    对象数组交换后：arrayb[0] = jmwang female, arrayb[1] = hwu male
    
    基本类型数组交换前：a[0] = 0, a[1] = 1
    基本类型数组交换前：b[0] = 1, b[1] = 2
    
    基本类型数组交换后：a[0] = 0, a[1] = 1
    基本类型数组交换后：b[0] = 1, b[1] = 2
    
    对象数组内容交换并改变后：arraya[1] = wjl male
    对象数组内容交换并改变后：arrayb[1] = Edward male
    
    基本类型数组内容交换并改变后：a[1] = 5
    基本类型数组内容交换并改变后：b[1] = 1

![复制代码][copycode.gif]

[view plain]: http://blog.csdn.net/jackson__qi/article/details/7982762#
[copycode.gif]: /images/20220731/31c5d901357e44e29713a7094c56fbbb.png