方法不能修改基本类型的参数，private int age=0,这里的age不是int型的吗。

private int age = 0;

public void setAge(int age) {
this.age = age;
}

age是对象参数。
setAge是方法，setAge可以修改age的值。

我不是高手，我是这样理解的。由不对的地方请指正。

class Test
{
  public static void main(String[] args)
  {
    StringBuffer sb = new StringBuffer("Hi, this is the init value of StringBuffer.");
    change(sb);
    System.out.println(sb);
  }
  
  static void change(StringBuffer sb)
  {
    sb.append("\nThis Content is changed!!!");
  }
}

HenryShanley wrote:
Java里面没有pass-by-reference的这个概念，所有的方法传递都是pass-by-value.d对于基本类型因为是传值，所以没有改变原来内存的数据，对于对象参数，传递的是引用的copy,(注意，也是值)，所以指向相同的内存数据。

Cappuccino wrote:
呵呵，最近在找工作，正好在某讨论面试题的帖子里面看到讨论这个问题。其实只是看字面意思怎么理解了，其实都是传的reference，你可以理解是reference的值，理解成指向原来的指针也勉强说得过去~~~ 知道是怎么回事就是了，真正问起来的时候照着书上说的按值传递就行了。

public void badSwap(Object var1, Object var2)
{
  Object temp = var1;
  var1 = var2;
  var2 = temp;
}

HenryShanley wrote:
Your understanding actually does not keep the term straight and consistent. And it is a common error made by Java language newcomers. Indeed, even senior engineers find it difficult.

Java does manipulate objects by reference, and all object variables are references. However, Java does *not* pass method arguments by reference; it passes them by value.

If you do think Java passes argument by reference, think about the following simple swap program. This is confusing because JAVA does not support *pointers*.

public void badSwap(Object var1, Object var2)
{
  Object temp = var1;
  var1 = var2;
  var2 = temp;
}

Notice that when badSwap() returns, the variable passed as arguments will still hold their original values. It is simply not how pass-by-reference works, since Java passes object reference by value. To be more accurate, when object type is passed to a method, JAVA passes the reference by value just like passing the primitive type, this means the references passed to the method are actually copies of the original references. (Notice that again, not the reference itself, but the copy it is, and i.e. the value of the reference.!!)

So let's look at the example above again, since the references are copies, swaps actually swap the copies and not the original references. Unfortunately, after a method call, you are left with only the unswapped original references. (If it is pass-by-reference, the original reference should be affected, hence the value swapped)

(Some more information about how C/C++ handles passing method parameters, you can ignore the following paragraph if you are not familiar with pointers)
In C/C++, if we pass a value to a method, then pass-by-value is used. In contrast, if we pass the variable address by using (& sign), then pass-by-reference approach is adopted. However, a programmer needs to explicitly defines a method declaration using (* sign). However, in JAVA, we cannot control pointers.

Regards,
Jiafan