【请教】关于Java函数传递参数的类型（传值还是传引用）

Question

Java里没有指针看起来似乎是简单了，可是有的时候我到觉得摸不着头了。
没有&和*的明显标记，我如何得知java在何种情况下是采用何种传递参数方式呢？
具体来说，大家能帮我实现如下代码吗？1。参数为int的函数，函数内对参数变量修改，不影响函数外的调用者
2。参数为int的函数，函数内对参数变量修改，同时影响到函数外的调用者
3。参数为Integer的函数，函数内对参数变量修改，不影响函数外的调用者
4。参数为Integer的函数，函数内对参数变量修改，同时影响到函数外的调用者

Answer 1

you have to understand the difference between the global varible and varible within scope.in java, only array use reference, that is transmit the address.

Answer 2

关于Java函数传递参数的类型（传值还是传引用） ----------
传值(对象类型传的是对象地址值)1)
public void changeInt(int i)
{
  i = 6; ....
}2)
public int changeInt(int i)
{
   return i + 2;
}3),4) 一样.

Answer 3

public class A {
    private int  i=5;
    public  void changeInt(int i)
    {
      i=10; 
    }    public static void main(String[] args) {
     changeInt(i);
     System.out.println(i);
}
}
解释一下这段代码的错误

Answer 4

我刚才又翻了翻别人的帖子，发现：1。简单类型的参数都是传值——也就是说任何函数内的修改都不会影响到函数外。2。复杂类型的参数比较混乱，比如传递一个StringBuffer类型的参数，
使用StringBuffer的成员函数造成的修改将会影响到函数外，比如append（）
不使用成员函数而直接用＝赋值，将不会影响到函数外3。java无法像其他语言那样实现类似这样的函数：void swap（int &a, int &b)
{
  int tmp = a;
  a = b;
  b = tmp;
}唉，还是有点儿乱

Answer 5

public class A {
    private int  i=5;
    public  void changeInt(int i)
    {
      i=10; 
    }    public static void main(String[] args) {
     changeInt(i);//你这个不是static方法，因此应该通过对象来调用
     System.out.println(i);//i的错误同上
}
}

Answer 6

public class A {
    private int  i=5;
    public  void changeInt(int i)
    {
      int i=10; 
      System.out.println("first" + i);
    }    public static void main(String[] args) {
     changeInt();
     System.out.println("Second: "+i);
}
}
first: 10
Second : 5

Answer 7

如果参数是primitive类型的，如：int ，float，double，long等，是值传递，即函数不改变实参的值
如果参数是对象，则传递的是reference，即类似指针，因此，函数要改变实参的值

Answer 8

public class A {
    int  i=5;
    public  void changeInt()
    {
      int i=10; 
      System.out.println("first" + i);
    }    public static void main(String[] args) {
     changeInt();
     System.out.println("Second: "+i);
}
}

Answer 9

楼上说得不完全对，实际上没有那么简单，请看如下例子：public   class   Test{   
  public   static   void   main(String[]   args){   
  StringBuffer   a=new   StringBuffer("A");   
  StringBuffer   b=new   StringBuffer("B");   
  operate(a,b);   
  System.out.println(a+","+b);   
    }   
  public   static   void   operate(StringBuffer   x,   StringBuffer   y){   
    x.append(y);   
    y=x;   
  }   
  }   
   
答案:AB,B

Answer 10

public static void main(String[] args) 这里是static的方法.如果调用static的话,就可以直接调用了.如果调用非static的变量或方法.就要A a = new A().

Answer 11

java都是传值
-------------------------------
如public void fun1(int i)//传的是 i的值
{
}
--------------------------------
Object oo = new Object();
fun2(oo);
public void fun2(Object obj)//传的是 obj(obj是一个对象的引用)的值
{
  obj = new Object();//obj引用了另一个对象，但oo并没改变
}

Answer 12

3。java无法像其他语言那样实现类似这样的函数：void swap（int &a, int &b)
{
  int tmp = a;
  a = b;
  b = tmp;
}这个是可以实现的啊,冒泡法就是这么实现的

Answer 13

y=x;  只是表示y和x都指向同一个对象，但是你并没有对y原先所指向的对象作改变，因此实参b所指向的对象也就没有改变，输出当然是B；这个和你在c/c++中传指针是一样的道理，你在函数中改变指针变量本身的值并不会改变指针指向对象的值；

Answer 14

同意楼上，JAVA和C/C++一样，永远都无法改变参数对象本身的值，而只能改变其所指向对象的值。从这个意义上来说，JAVA，C/C++的函数都是传值的。

Answer 15

http://blog.csdn.net/f_acme/archive/2006/02/25/609620.aspx

Answer 16

我的理解是：
  java中函数传递参数的方式都是 『传值』，这是最根本的。
  对于基本型变量如int、float等来说，传递的是变量的内容，函数中的产生一个新的变量来接收参数的值，它们两个是两个内容一样的 『不同变量』  ，所以在函数中改变不会影响到原来的变量。
对于参数是对象来说，传递的是对象引用的一个副本，也就是说，函数中产生了一个引用变量，这个引用变量的值和作为参数传过来的那个变量的值是一样的，这两个不同的变量指向内存中同一个地址，即同一个对象。那么此时就有两种情况，假设a为函数中的接收参数的变量：
    1.当执行如a＝其他对象，a＝new等赋值操作时，实际上是将a指向新的位置，那么函数外的原值不改变。
    2.如果在函数中执行的是对a的成员变量的操作，或者调用对象中修改成员变量的函数，那么就改变了原值。