Java方法传递参数说明

我们都知道，Java中对于基本数据类型作为方法参数时，都是值传递。

那么对象作为方法的参数，又是传递的什么呢？

java的方法参数都是传值，没有传引用。很多人都以为是传引用，而且这种错误的观点很普遍，今天在这里具体分析一下。方法参数有基本类型，如int等，另外一种类型是OBJECT，对象。详细说一下方法参数是对象的，JAVA方法参数传对象，传的是对这个对象引用的一份拷贝，即地址值，跟原来的引用都是指向同一个对象。所以说，JAVA方法参数传的都是值。

 

也可以说当方法参数是对象时，传递的是引用，只是它并不是传递的对象的原始引用，而是原始引用的一个拷贝。也就是说当将对象作为参数传递给方法后，就会有两个引用，指向同一个对象地址。

 

程序一 传的对象值是改变的。

Java代码  

1. public class Test {   
2.     public Test() {   
3.         int[] count = { 5 };   
4.         change(count);   
5.         System.out.println(count[0]);   
6.     }   
7.   
8.     public void change(int[] counts) {   
9.         counts[0] = 6;   
10.         System.out.println(counts[0]);   
11.     }   
12.   
13.     public static void main(String[] args) {   
14.         Test t = new Test();   
15.     }   
16. }  

    public class Test {        public Test() {            int[] count = { 5 };            change(count);            System.out.println(count[0]);        }        public void change(int[] counts) {            counts[0] = 6;            System.out.println(counts[0]);        }        public static void main(String[] args) {            Test t = new Test();        }    }

 

程序一中，输出结果都是6，change(count); 把对象的一份引用拷贝传给change（），这个拷贝跟原来的引用都是指向同一个对象。所以改变引用拷贝的值，对象的值也跟着改变。

 

程序二 传的对象值不改变

Java代码  

1. class Foo {   
2.     int i = 0;   
3. }   
4.   
5. public class A {   
6.     public static void main(String args[]) {   
7.         Foo f = new Foo();   
8.         add(f);   
9.         System.out.println(f.i);   
10.     }   
11.   
12.     public static void add(Foo f) {   
13.         f = new Foo();   
14.         f.i++;   
15.     }   
16. }  

    class Foo {        int i = 0;    }    public class A {        public static void main(String args[]) {            Foo f = new Foo();            add(f);            System.out.println(f.i);        }        public static void add(Foo f) {            f = new Foo();            f.i++;        }    }

 

输出结果是0
程序2中，也是传一份引用的拷贝，但在 add()方法中，f=new Foo(); new出了一个新的对象，所以引用的拷贝指向了一个新的对象。原来的引用还是指向原来的对象，所以原来的值还是没有改变。

从这一点就可以看出，确实产生了一个引用的拷贝。

 

程序三 String不改变，数组改变

Java代码  

1. public class Example {   
2.     String str = new String("good");   
3.     char[] ch = { 'a', 'b', 'c' };   
4.     public static void main(String args[]) {   
5.         Example ex = new Example();   
6.         ex.change(ex.str, ex.ch);   
7.         System.out.print(ex.str + " and ");   
8.         Sytem.out.print(ex.ch);   
9.     }   
10.   
11.     public void change(String str, char ch[]) {   
12.         str = "test ok";   
13.         ch[0] = 'g';   
14.     }   
15. }  

    public class Example {        String str = new String("good");        char[] ch = { 'a', 'b', 'c' };        public static void main(String args[]) {            Example ex = new Example();            ex.change(ex.str, ex.ch);            System.out.print(ex.str + " and ");            Sytem.out.print(ex.ch);        }        public void change(String str, char ch[]) {            str = "test ok";            ch[0] = 'g';        }    }

 

程序3输出的是 good and gbc.
String 比较特别，是因为java在传string的时候把string当成基本类型来处理 。所以值是不变的。