JAVA的课件

                        破除java神话之二：参数是传址的（翻译） 阅读次数2339 
                        出处 http://www.javaresearch.org/ cherami     


                              作者：Cherami 

                              email:[e-mail]




                              在不同的java新闻组中，参数是传值还是传址一直是一个经常被争辩的话题。误解的中心是以下两个事实：

                              1、对象是传引用的

                              2、参数是传值的

                              这两个能够同时成立吗？一个字：是！在java中，你从来没有传递对象，你传递的仅仅是对象的引用！一句话，java是传引用的。然而，当你传递一个参数，那么只有一种参数传递机制：传值！


                              通常，当程序员讨论传值和传引用时，他们是指语言的参数传递机制，c++同时支持这两种机制，因此，以前使用过c++的程序员开始好像不能确定的java是如何传参数的。java语言为了事情变得简单只支持参数传值的机制。

                              java中的变量有两种类型：引用类型和原始类型。当他们被作为参数传递给方法时，他们都是传值的。这是一个非常重要的差别，下面的代码范例将说明这一点。

                              在继续前，我们有必要定义一下传值和传引用。传值意味着当参数被传递给一个方法或者函数时，方法或者函数接收到的是原始值的副本。因此，如果方法或者函数修改了参数，受影响的只是副本，原始值保持不变。

                              关于java中的参数传递的混乱是因为很多java程序员是从c++转变过来的。c++有引用和非引用类型的变量，并且分别是通过传引用和传值得。java语言有原始类型和对象引用，那么，按照逻辑，java对于原始类型使用传值而对引用是传引用的，就像c++一样。毕竟，你会想到如果你正在传递一个引用，那么它一定是传引用的。这是一个很诱惑人的想法，但是是错误的！

                              在c++和java中，当函数的参数不是引用时，你传递的是值得副本（传值）。但是对于引用类型就不同了。在c++中，当参数是引用类型，你传递的是引用或者内存地址（传引用），而在java中，传递一个引用类型的参数的结果只是传递引用的副本（传值）而非引用自身。这是一个非常重要的区别！java不考虑参数的类型，一律传递参数的副本。

                              仍然不信？如果java中是传引用，那么下面的范例中的swap方法将交换他们的参数。因为是传值，因此这个方法不是像期望的那样正常工作。



class Swap
{
public static void main(String args[]) 
{ 
Integer a, b; 
int i,j;
a = new Integer(10);
b = new Integer(50); 
i = 5;
j = 9; 
System.out.println("Before Swap, a is " + a); 
System.out.println("Before Swap, b is " + b); 
swap(a, b); 
System.out.println("After Swap a is " + a); 
System.out.println("After Swap b is " + b); 
System.out.println("Before Swap i is " + i); 
System.out.println("Before Swap j is " + j); 
swap(i,j); 
System.out.println("After Swap i is " + i);
System.out.println("After Swap j is " + j); 
}
public static void swap(Integer ia, Integer ib)
{
Integer temp = ia; 
ia = ib; 
ib = temp; 
}
public static void swap(int li, int lj) 
{ 
int temp = li; 
li = lj; 
lj = temp; 
} 
} 


                              上面程序的输出是: 



Before Swap, a is 10 
Before Swap, b is 50
After Swap a is 10 
After Swap b is 50 
Before Swap i is 5 
Before Swap j is 9 
After Swap i is 5 
After Swap j is 9 

                              因为swap方法接收到的是引用参数的副本（传值），对他们的修改不会反射到调用代码。


                              译者注：在传递引用和原始类型时还是有不同的，考虑以下的代码：


class Change
{
public static void main(String args[]) 
{ 
StringBuffer a=new StringBuffer("ok"); 
int i;
i = 5;
System.out.println("Before change, a is " + a); 
change(a); 
System.out.println("After change a is " + a); 
System.out.println("Before change i is " + i); 
change(i); 
System.out.println("After change i is " + i);
}
public static void change(StringBuffer ia)
{
ia.append(" ok?");
}
public static void change(int li) 
{ 
li = 10; 
} 
}

                              程序的输出为：



Before change, a is ok
After change a is ok ok?
Before change i is 5
After change i is 5

                              ，即如果传递的是引用，那么可以修改引用对象的内容，这个改变会影响到原来的对象，而传递的如果是原始类型则不会有影响。这个也是造成误解的原因之一吧。

                              版权声明 



                              Re: 破除java神话之二：参数是传址的（翻译） 
                              subwater 积分: 1 发表时间: Jun 27, 2002 9:35 PM 评论 

                              我个人觉得觉得作者有些弯曲了传址的概念，其实C++里也是同样的。如下面的代码：

                              //example 1
                              #include 
                              void exch(int *p1,int *p2);

                              int main()
                              { 
                              int i =1,j=2;
                              cout<<"i="< return 0;
                              }

                              void exch(int *p1,int *p2)
                              {
                              int* temp;
                              temp = p1;
                              p1 = p2;
                              p2 = temp;
                              }
                              //end example 1

                              结果会是：
                              i=1,j=2
                              i=1,j=2

                              同样不会发生任何变化，正确的写法应该是

                              //example 2
                              #include 
                              void exch(int *p1,int *p2);

                              int main()
                              { 
                              int i =1,j=2;
                              cout<<"i="< return 0;
                              }

                              void exch(int *p1,int *p2)
                              {
                              int temp;
                              temp = *p1;
                              *p1 = *p2;
                              *p2 = temp;
                              }
                              //end example 2
                              结果会是：
                              i=1,j=2
                              i=2,j=1


                              如上面代码说明的一样，其实无论何种语言传址方法都是一样的。传值和传址都是把内容复制给形参。只是传值复制得是变量的具体的值，而传址复制的是存放给变量的地址。你只是改变了形参里的地址，变量当然没有变化，你只有改变该地址里的值，才可以改变该变量的值。
                              C++里如果要改变两个地址，应该传的是个指向指针的指针。如下面的代码：
                              //example 2
                              #include 
                              void exch(int **p1,int **p2);

                              int main()
                              { 
                              int a =1,b = 2;
                              int *i = &a;
                              int *j = &b;
                              cout<<"a="< return 0;
                              }

                              void exch(int **p1,int **p2)
                              {
                              int* temp;
                              temp = *p1;
                              *p1 = *p2;
                              *p2 = *temp;
                              }
                              //end example 2
                              结果会是：
                              a=1,b=2
                              *i=1,*j=2
                              a=1,b=2
                              *i=2,*j=1

                              而Java中可以用这样的例子：
                              public class Test 
                              {
                              public static void swap(Integer[] a)
                              {
                              Integer temp= a[0];
                              a[0] = a[1];
                              a[1] = temp;
                              }

                              public static void main(String[] args) 
                              {
                              Integer[] one = new Integer[2];
                              one[0] = new Integer(17);
                              one[1] = new Integer(3);
                              System.out.println("before swap");
                              System.out.println("one[0] is"+one[0]);
                              System.out.println("one[1] is"+one[1]);
                              swap(one);
                              System.out.println("after swap");
                              System.out.println("one[0] is"+one[0]);
                              System.out.println("one[1] is"+one[1]);
                              }
                              }
                              结果是：
                              before swap
                              one[0] is 17
                              one[1] is 3
                              after swap
                              one[0] is 3
                              one[1] is 1

                   整理发布
                   
                   
                               发言人:过客   日期：2002-07-10

                              好


                               发言人:过客   日期：2002-08-19

                              深得我心啊！


                               发言人:过客   日期：2002-09-05

                              写得好


                               发言人:bright_wang   日期：2002-09-10

                              ok<br /> 


                               发言人:whin   日期：2003-01-01

                               非常好！应当再仔细一点！


                               发言人:过客   日期：2006-07-26

                              其实,无论是C++还是Java,她们的传值和传地址的机制都是一样的.要知道Java里面的对象都是new出来的.这样一来就好理解了.