一道关于JAVA传值的选择题，请朋友们帮我分析一下谢谢了

Question

public class Test{
 int a;
int b;public void f(){
a =0;
b=0;
int [] c ={0};
g(b,c);
System.out.println(a+" "+b+" "+c[0]+" ");
}
public vodi g(int b,int[] c){a=1;
b=1;
c[0]=1;}public static  void mian(String args){
Test obj = new Test();
obj.f();
}打印出来是 1 0 1 应该怎么理解JAVA的传值？  谢谢了！

Answer 1

当参数为“数组”或“状态可转换对象”时，传递的是引用;当参数为“状态不可转换对象”时，传递的是值。
“状态可转换对象”即 此对象中存在改变对象本身状态（所存储的内容）的方法。如StringBuffer。

Answer 2

public vodi g(int b,int[] c){a=1;
b=1;
c[0]=1;}你把这里的参数 int b 改成int d或者其他的值，结果就是 1，1，1了。
因为参数里重新定义了b，所以2个b不一样。

Answer 3

当参数为“数组”或“
     状态可转换对象”时，传递的是引用;当参数为“状态不可转换对象”时，传递的是值。 
“状态可转换对象”即   此对象中存在改变对象本身状态（所存储的内容）的方法。如StringBuffer。这个怎么理解啊？ 能否结合上面的题目讲讲？

Answer 4

基本类型：int,float,byte,short,char,double,string,long传值。
其它对象类型：传引用。
在你的方法g里面，int b是是基本类型，传值，[]c是对象，传引用。

Answer 5

额，
关于这道题目，课本中给出的解释是这样的：请帮我翻成中文吧 谢谢
In java, method arguments are passed by value. When the g() method is called, the argument
b receives a copy of the instance variable b.Since the copy alone is modified , the change of value in parameter b is confined to the g() method.So b's valueremains 0. However, the change made to the instance variable a is reflected , sinc there is only copy of a . So the
value of a becomes 1.

Answer 6

上面的英文翻译（翻的不好不要见笑@_@):在JAVA中，函数的参数是通过传值来实现的。当函数g()被调用的时候，参数b会收到一份复制的对象的参数b。因为只是复制的那个参数b被改变了，在函数个g()中所改变的那个参数b是受函数本身限制的。所以对象中的b的值还是0，但是对象中的值a却改变了，因为对象参数a只有一个，并没有被复制，所以a的值变成了1.

Answer 7

a 和 C[] 只有一份  b 有两份 ？

Answer 8

楼上给出的英文解释很烂哟，都没分析b和[]c的区别，净在那侃a和b。

Answer 9

很简单，你只要记住，在Java中参数的传递不管是基本数据类型，还是引用数据类型，都是传值。也就是说，对于基本数据类型，传递的是本身的值，而对于引用数据类型，传递的是引用的值（地址）。现在来分析这段代码：
public class Test{
  int a;       // 成员变量，基本数据类型
  int b;       // 成员变量，基本数据类型public void f(){
  a = 0;       // 对成员变量赋值
  b = 0;       // 对成员变量赋值
  // 定义了一个局部变量，是一个int类型的数组，记住，数组是一个引用数据类型，c这个数组的元素是基本数据类型
  int[] c = {0};  
  g(b, c);
  System.out.println(a + " " + b + " " + c[0] + " ");
}public vodi g(int b, int[] c){
  a = 1;      // 这里是对成员变量赋值
  b = 1;      // 而这个b是参数，可以看成是一个局部变量，对这个局部变量赋值不会改变你的成员变量
  c[0] = 1;   // 参数c是一个数组，其值与f()方法中的局部变量数组c的值是一样的，都指向堆内存中同一块地址，所以这里对其元素c[0]重新赋值也就会影响到原来的数组元素
}public static void mian(String args){
  Test obj = new Test();
  obj.f();
}所以，结果就是1 0 1你可以画内存图，将栈内存和堆内存图画出来就很容易明白。

Answer 10

不要管什么一份两份 java里只有传值 
public   vodi   g(int   b,int[]   c){ 
  a=1; 
  b=1; 
  c[0]=1; 
} 
b是g()括号里的b 与外围的b无关 所以原来b是多少就是多少 
a=1 应该很好理解吧
c[0]=1 传进来的是c[] 不是c[0] 所以你可以改变c[0]的值public void g(int b,int[] c){
  int[] d={2};
  a=1;
  b=1;
  c=d;
}
这样c[0]还是0这样理解不知道对不对 反正结果应该不会错

Answer 11

我不知道内存是怎么分配的 反正结果不会错
public class Test{
 int a;
 int b;public void f(){
a =0;
b=0;
int [] c ={0,0};
g(b,c);
System.out.println(a+" "+b+" "+c[0]+c[1]+" ");
}
public void g(int b,int[] c){
int[] d={2,3};
a=1;
b=1;
c=d;
c[0]=1;
}public static  void main(String[] args){
Test obj = new Test();
obj.f();
}
}这样的结果是 1 0 00如果改成
public void g(int b,int[] c){
int[] d={2,3};
a=1;
b=1;
c[0]=1；
c=d;
}
那结果就是 1 0 10

Answer 12

把g改成 public  void  g(int e,int[] f)不就什么都清楚了

Answer 13

public class Test{
 int a;
int b;public void f(){
a =0;
b=0;
int [] c ={0};
g(b,c);
System.out.println(a+" "+b+" "+c[0]+" ");
}
public vodi g(int b,int[] c){a=1;//注意这里的a是类属性字段a
b=1;//注意这里的b是g()方法中的局部变量
c[0]=1;//注意这里的c是传进来的数组c}public static  void mian(String args){
Test obj = new Test();
obj.f();
}
java里面的参数传递：java里简单的值类型是传值byte,short,int,long,double,float,boolean,char
其他的都是传引用:包括数组和字符串

Answer 14

a 是实例变量，直接在f()中被赋1
b 是基本类型，传值，在f()中的赋值不会影响实例变量的b，所有实例变量是缺省值0
c[] 是引用类型，传引用，所以对c[0]的赋值会影响到实例变量的c[]。_________________
欢迎到我在技术圈的Java圈子做客:Java Guru

Answer 15

很简单，你只要记住，在Java中参数的传递不管是基本数据类型，还是引用数据类型，都是传值。也就是说，对于基本数据类型，传递的是本身的值，而对于引用数据类型，传递的是引用的值（地址）。现在来分析这段代码： public   class   Test{ 
    int   a;               //成员变量，基本数据类型 
    int   b;               //成员变量，基本数据类型 public   void   f(){ 
    a   =   0;               //对成员变量赋值 
    b   =   0;               //对成员变量赋值 
    //   定义了一个局部变量，是一个int类型的数组，记住，数组是一个引用数据类型，c这个数组的元素是基本数据类型 
    int[]   c   =   {0};     
    g(b,   c); 
    System.out.println(a   +   "   "   +   b   +   "   "   +   c[0]   +   "   "); 
} public   vodi   g(int   b,   int[]   c){ 
    a   =   1;             //   这里是对成员变量赋值 
    b   =   1;             //   而这个b是参数，可以看成是一个局部变量，对这个局部变量赋值不会改变你的成员变量 
    c[0]   =   1;       //   参数c是一个数组，其值与f()方法中的局部变量数组c的值是一样的，都指向堆内存中同一块地址，所以这里对其元素c[0]重新赋值也就会影响到原来的数组元素 
} public   static   void   mian(String   args){ 
    Test   obj   =   new   Test(); 
    obj.f(); 
} 请问东方文你说的成员变量 是否是指全局变量？
第一次定义的b 和 g（）函数的中b 不是一个b？ 所以 b=0？
而第一次定义的变量a 和 g（）函数中的a是同一个a？ 所以a=1？
而第一定义的c【】由于是一个object， 在g（）函数中只是把他对应引用的改变了？（原来是0 变成了1）所以 c【0】=1？？

Answer 16

全部看完,感觉很多都是在误人子弟,JAVA里哪里有传引用的,都是传值的,
东方文,和国际性文化传播有限公司已经解释的很清楚了

Answer 17

做了如下几个测试，终于知道了pass-by-value 和 pass-by-reference的不同了，但是不知道怎么讲出来！class PassByValue
{
int a,b; public void f(){
int[] c = {0,0};
a=0;
b=0;
g(b,c);
System.out.println("a:"+a+"  b:"+b+
"  c[0][1]:"+c[0]+c[1]);

} public void g(int b,int[]d ){
a=1;
b=1;
int[]e={2,3};
d=e;
e[0]=1; System.out.println(" d[]:"+d[0]+d[1]);
} public static void main(String[] args) 
{
new PassByValue().f();
}
}
结果： 
d[]:13
a:1  b:0  c[0][1]:00

Answer 18

其实很简单，JAVA语言中有两种数据类型，一种是基本数据类型，别一种是引用数据类型，基本数据类弄采用的是传值即传递给形式参数的是变量的传，而引用数据类类型传递给形式参数的是变量的地址，即在目标方法中对该变量操作是直接对其内存单元中的数据进行了更改，而前只是对变量值的使用。

Answer 19

同意13楼的意见。  分析得很清楚了。关于JAVA里的传值问题，自己确实是应该在内存堆图里自己体会一下。

Answer 20

没搞过这么复杂的问题，刚学编程时一看到这样的题目，只告诉自己一句话，“不要把变量名搞得一样”，
这个程序要是我来写就是这样：
public class Test{
int a;
int b;public void f(){
a =0;
b=0;
int [] c ={0};
g(b,c);
System.out.println(a+" "+b+" "+c[0]+" ");
}
public void g(int d,int[] e){a=1;
d=1;//如果是要写b=1那b的值肯定会变
e[0]=1;//想写c[0]=1？可以试试看}public static  void main(String args){
Test obj = new Test();
obj.f();
}
这样
>>打印出来是   1   0   1   应该怎么理解JAVA的传值？
就很容易理解了，这段程序说明的就是整数值不能传出，数组的值可以传出。
至于什么变量范围，基本都是不记的，就像运算符的优先级，用括号就好了。
（事实上见得多了，自然就记住了，一开始就整这种在实际写程序中不会写的程序，有什么意义？想写编译器为生的同学除外）要把问题搞复杂还不简单吗？就像下面：不简单吗还问题搞复杂要把有这么说话的程序员吗？

Answer 21

java中其实都是值传递,而且传进去的都是这个值的一个副本
对于基本数据类型,由于你操作的是副本,所以不会对原始值产生影响,如你例子中的b
对于引用数据类型,由于副本和原始值都指向的是同一个对象,所以你操作副本和操作原始值其实都是操作的同一个对象,如你例子中的c

Answer 22

按照程序依次执行，
Java code
public class Test{
 int a;
int b;public void f(){
a =0;//a=0;
b=0;//b=0
int [] c ={0};//c=0
g(b,c);
System.out.println(a+" "+b+" "+c[0]+" ");//a=1,b=0,c[]=1
}
public vodi g(int b,int[] c){a=1;//这里的a是类的成员变量，所以a=1
b=1;//而这里的b不是类的成员变量，而是局部变量，所以原由类的成员变量b仍为0
c[0]=1;//而这里传递为数组的地址，因此修改的仍为成员变量c的内容c=1，注意JAVA中没有C++中所谓的引用传值，而只有值传递，不过对于数组而言
        //其传递的是该数组的地址，因此对数组的修改仍然为对其原有地址内容的修改}public static  void mian(String args){
Test obj = new Test();
obj.f();
}

Answer 23

很简单:java方法的参数都是传值,
注意,何谓传值,比如说,你方法定义的参数,
如果是基本类型,则把基本类型的值赋给他,这个大家都知道如果是引用类型,首先解释下,引用类型的地址是放在栈中的,而值是放堆中的.比如,有个bean是 Student(String id ,String name)
有一个方法接受此类型的参数
g(Student copya){   copya.setId("b");}
-----
我们执行
Student a = new Student("a","a-")
g(a);
System.print.out("a.id = "+a.getId);
-------
结果:
a.id = b;
这个过程做了什么呢,对了,首先,调用a的clone方法复制了一份,取名就叫copya,即方法的形参名
然后,还做了一点,把原先a的 id 和 name ,也就是 "a" "a-"的堆地址给了copya
而copya.setId("b");则改变了这一堆地址的值.而此是a,copya的id都是指向"a"这个堆地址的,
所以必然输出b数组也是同理:和set,get方法一样.c[1]=0,是指向堆,而不是栈的,请注意这点.如果我们把上面的代码改一下,改成这样看看g(Student copya){   Student b = new Student("b","b-");
   copya=b;
}
-----
我们执行
Student a = new Student("a","a-")
g(a);
System.print.out("a.id = "+a.getId);
-------
结果:
a.id = a;为什么呢,我们创建的b,把b赋予这个copya,但是这个copya只是一个引用地址,把b的引用地址给copya,
而copya只是a复制的一个对象而已,因为是传值.总结:主要要分清传值的本质,引用类型的值放在堆中,而我们传值的时候,
会让这个复制对象的元素指向这些地址,而这地址是和原先被传对象共享的.所以,我们对这个复制对象改变元素,也就改变了原先对象的值.

Answer 24

很简单:java方法的参数都是传值,
注意,何谓传值,比如说,你方法定义的参数,
如果是基本类型,则把基本类型的值赋给他,这个大家都知道如果是引用类型,首先解释下,引用类型的地址是放在栈中的,而值是放堆中的.比如,有个bean是 Student(String id ,String name)
有一个方法接受此类型的参数
g(Student copya){   copya.setId("b");}
-----
我们执行
Student a = new Student("a","a-")
g(a);
System.print.out("a.id = "+a.getId);
-------
结果:
a.id = b;
这个过程做了什么呢,对了,首先,调用a的clone方法复制了一份,取名就叫copya,即方法的形参名
然后,还做了一点,把原先a的 id 和 name ,也就是 "a" "a-"的堆地址给了copya
而copya.setId("b");则改变了这一堆地址的值.而此是a,copya的id都是指向"a"这个堆地址的,
所以必然输出b数组也是同理:和set,get方法一样.c[1]=0,是指向堆,而不是栈的,请注意这点.如果我们把上面的代码改一下,改成这样看看g(Student copya){   Student b = new Student("b","b-");
   copya=b;
}
-----
我们执行
Student a = new Student("a","a-")
g(a);
System.print.out("a.id = "+a.getId);
-------
结果:
a.id = a;为什么呢,我们创建的b,把b赋予这个copya,但是这个copya只是一个引用地址,把b的引用地址给copya,
而copya只是a复制的一个对象而已,因为是传值.总结:主要要分清传值的本质,引用类型的值放在堆中,而我们传值的时候,
会让这个复制对象的元素指向这些地址,而这地址是和原先被传对象共享的.所以,我们对这个复制对象改变元素,也就改变了原先对象的值.