1   #include<iostream> 2   using namespace std; 3   void swap(int,int);//函数声明 4    5  void main() 6    7   { 8   9   　　int a=2,b=3;10 11  　　swap(a,b);//调用时，形参x、y重新申请了空间，把a、b值拷贝到形参，不对实参产生影响12  13 　　cout<<"a = "<<a<<",b = "<<b<<endl;14 15  }16  17 　void swap(int x,int y)//函数定义18 19  {20 21  　　　int temp = x;22 23 　　　　x = y;24 25 　　　　y = temp;26 27 　　}28 29 执行结果如下：30 a = 2，b = 3

 1   #include<iostream> 2   using namespace std; 3   void swap(int *,int *);//函数声明 4    5  void main() 6    7   { 8   9   　　int a=2,b=3;10 11  　　swap(&a,&b);//swap中不是交换了x和y的值，而是交换了两个指针指向的两个地址处的值；因为同一地址的数据值是相同的，从而间接地达到了回传参数的目的12  13 　　cout<<"a = "<<a<<",b = "<<b<<endl;14 15  }16  17 　void swap(int *x,int *y)//函数定义18 19  {20 21  　　　int temp = *x;//"*"符号表示取指针指向的值22 23 　　　　*x = *y;24 25 　　　　*y = temp;26 27 　　}28 29 执行结果如下：30     a = 3，b = 2

 1   #include<iostream> 2   using namespace std; 3   void swap(int &,int &);//函数声明 4    5  void main() 6    7   { 8   9   　　int a=2,b=3;10 11  　　swap(&a,&b);//将实参的地址放入C++为形参分配的内存空间中12  13 　　cout<<"a = "<<a<<",b = "<<b<<endl;14 15  }16  17 　void swap(int &x,int &y)//函数定义18 19  {20 21  　　　int temp = x;//引用使用的时候，直接当变量名用22 23 　　　　x = y;24 25 　　　　y = temp;26 27 　　}28 29 执行结果如下：30     a = 3，b = 2

 1 class Test 2  3 { 4  5 　　private int a; 6  7 　　private int b; 8  9 10 11 　　//swap函数没有使用形参的必要性，本身就可以直接操作内成员a，b，不存在参数拷贝,a,b值交换成功12 13 　　public void swap()14 15 　　{16 17 　　　　int temp = this.a;18 19 　　　　this.a = b;20 21 　　　　this.b = temp;22 23 　　}　　24 25 }

public static void main（String []args){    int a[] = {1,2};    int temp = a[0];    a[0] = a[1];    a[1] = temp;    System.out.println("a[0] = " + a[0] + ",a[1] = " + a[1]);}打印结果：a[0] = 2,a[1] = 1

    public static void main(String args[])    {          int a[] = {1,2};          int b[] = {3,4};          int temp[] = a;          a = b;          b = temp;        for(int i=0;i<a.length;i++)        {          System.out.print("a[" + i + "]=" + a[i] + " ");        }        System.out.println();      for(int j=0;j<b.length;j++)      {          System.out.print("b[" + j + "]=" +b[j] + " ");      }    } 打印结果：a[0]=3 a[1]=4 b[0]=1 b[1]=2

public class ReferValue{    static String ss = "hello";     public static void change(String str)    {        str = "world";//调用change函数时，传ReferValue.ss,不能改变成员ss值。

　　　　//　ss = "ss changed";//直接反问修改，可以改变ss值

 　　} 
　　public static void main(String args[])
　　{
　　　　change(ReferValue.ss);//将类或者对象的成员变量，“暴露出来”，当成实参传递给形参，这种做法就有待商榷。

　　}
}

Passing Information to a Method or a Constructor

Passing Primitive Data Type Arguments

Primitive arguments, such as an int or a double, are passed into methods by value. This means that any changes to the values of the parameters exist only within the scope of the method. When the method returns, the parameters are gone and any changes to them are lost. Here is an example:

public class PassPrimitiveByValue {    public static void main(String[] args) {                   int x = 3;                   // invoke passMethod() with         // x as argument        passMethod(x);                   // print x to see if its         // value has changed        System.out.println("After invoking passMethod, x = " + x);               }            // change parameter in passMethod()    public static void passMethod(int p) {        p = 10;    }}

When you run this program, the output is:

After invoking passMethod, x = 3

Passing Reference Data Type Arguments

Reference data type parameters, such as objects, are also passed into methods by value. This means that when the method returns, the passed-in reference still references the same object as before.However, the values of the object‘s fields can be changed in the method, if they have the proper access level.

For example, consider a method in an arbitrary class that moves Circle objects:

public void moveCircle(Circle circle, int deltaX, int deltaY) {    // code to move origin of circle to x+deltaX, y+deltaY    circle.setX(circle.getX() + deltaX);    circle.setY(circle.getY() + deltaY);            // code to assign a new reference to circle    circle = new Circle(0, 0);}

Let the method be invoked with these arguments:

moveCircle(myCircle, 23, 56)

　　Inside the method, circle initially refers to myCircle.

　　The method changes the x and y coordinates of the object that circle references (i.e., myCircle) by 23 and 56, respectively. These changes will persist when the method returns.

　　Then circle is assigned a reference to a new Circle object with x = y = 0. This reassignment has no permanence, however, because the reference was passed in by value and cannot change. Within the method, the object pointed to by circle has changed, but, when the method returns, myCircle still references the same Circle object as before the method was called.