现在的位置: 首页 > 综合 > 正文

Java 应用程序中的按值传递语义

2018年05月25日 ⁄ 综合 ⁄ 共 16838字 ⁄ 字号 小 中 大 ⁄ 评论关闭

在不同的java新闻组中，参数是传值还是传址一直是一个经常被争辩的话题。误解的中心是以下两个事实：<BR>
1、对象是传引用的<BR>
2、参数是传值的<BR>
这两个能够同时成立吗？一个字：是！在java中，你从来没有传递对象，你传递的仅仅是对象的引用！一句话，java是传引用的。然而，当你传递一个参数，那么只有一种参数传递机制：传值！<BR>

通常，当程序员讨论传值和传引用时，他们是指语言的参数传递机制，c++同时支持这两种机制，因此，以前使用过c++的程序员开始好像不能确定的java是如何传参数的。java语言为了事情变得简单只支持参数传值的机制。<BR>
java中的变量有两种类型：引用类型和原始类型。当他们被作为参数传递给方法时，他们都是传值的。这是一个非常重要的差别，下面的代码范例将说明这一点。<BR>
 在继续前，我们有必要定义一下传值和传引用。传值意味着当参数被传递给一个方法或者函数时，方法或者函数接收到的是原始值的副本。因此，如果方法或者函数修改了参数，受影响的只是副本，原始值保持不变。<BR>
关于java中的参数传递的混乱是因为很多java程序员是从c++转变过来的。c++有引用和非引用类型的变量，并且分别是通过传引用和传值得。java语言有原始类型和对象引用，那么，按照逻辑，java对于原始类型使用传值而对引用是传引用的，就像c++一样。毕竟，你会想到如果你正在传递一个引用，那么它一定是传引用的。这是一个很诱惑人的想法，但是是错误的！<BR>
 在c++和java中，当函数的参数不是引用时，你传递的是值得副本（传值）。但是对于引用类型就不同了。在c++中，当参数是引用类型，你传递的是引用或者内存地址（传引用），而在java中，传递一个引用类型的参数的结果只是传递引用的副本（传值）而非引用自身。这是一个非常重要的区别！java不考虑参数的类型，一律传递参数的副本。<BR>
 仍然不信？如果java中是传引用，那么下面的范例中的swap方法将交换他们的参数。因为是传值，因此这个方法不是像期望的那样正常工作。<BR>
<pre>
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; 
 } 
} 
</pre>
 
上面程序的输出是: <BR>
<PRE>
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 
</PRE>
因为swap方法接收到的是引用参数的副本（传值），对他们的修改不会反射到调用代码。<BR>

译者注：在传递引用和原始类型时还是有不同的，考虑以下的代码：
<pre>
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; 
 } 
}
</pre>
程序的输出为：<BR>
<PRE>
Before change, a is ok
After change a is ok ok?
Before change i is 5
After change i is 5
</PRE>
，即如果传递的是引用，那么可以修改引用对象的内容，这个改变会影响到原来的对象，而传递的如果是原始类型则不会有影响。这个也是造成误解的原因之一吧。
 

Java 应用程序中的按值传递语义


节选理解参数是按值而不是按引用传递的说明 Java 应用程序有且仅有的一种参数传递机制，即按值传递。写它是为了揭穿普遍存在的一种神话，即认为 Java 应用程序按引用传递参数，以避免因依赖“按引用传递”这一行为而导致的常见编程错误。

对此节选的某些反馈意见认为，我把这一问题搞糊涂了，或者将它完全搞错了。许多不同意我的读者用 C++ 语言作为例子。因此，在此栏目中我将使用 C++ 和 Java 应用程序进一步阐明一些事实。

要点 
读完所有的评论以后，问题终于明白了，至少在一个主要问题上产生了混淆。某些评论认为我的节选是错的，因为对象是按引用传递的。对象确实是按引用传递的；节选与这没有冲突。节选中说所有参数都是按值 -- 另一个参数 -- 传递的。下面的说法是正确的：在 Java 应用程序中永远不会传递对象，而只传递对象引用。因此是按引用传递对象。但重要的是要区分参数是如何传递的，这才是该节选的意图。Java 应用程序按引用传递对象这一事实并不意味着 Java 应用程序按引用传递参数。参数可以是对象引用，而 Java 应用程序是按值传递对象引用的。

C++ 和 Java 应用程序中的参数传递 
Java 应用程序中的变量可以为以下两种类型之一：引用类型或基本类型。当作为参数传递给一个方法时，处理这两种类型的方式是相同的。两种类型都是按值传递的；没有一种按引用传递。这是一个重要特性，正如随后的代码示例所示的那样。

在继续讨论之前，定义按值传递和按引用传递这两个术语是重要的。按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本。因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本。因此，如果函数修改了该参数，调用代码中的原始值也随之改变。

关于 Java 应用程序中参数传递的某些混淆源于这样一个事实：许多程序员都是从 C++ 编程转向 Java 编程的。C++ 既包含非引用类型，又包含引用类型，并分别按值和按引用传递它们。Java 编程语言有基本类型和对象引用；因此，认为 Java 应用程序像 C++ 那样对基本类型使用按值传递，而对引用使用按引用传递是符合逻辑的。毕竟您会这么想，如果正在传递一个引用，则它一定是按引用传递的。很容易就会相信这一点，实际上有一段时间我也相信是这样，但这不正确。

在 C++ 和 Java 应用程序中，当传递给函数的参数不是引用时，传递的都是该值的一个副本（按值传递）。区别在于引用。在 C++ 中当传递给函数的参数是引用时，您传递的就是这个引用，或者内存地址（按引用传递）。在 Java 应用程序中，当对象引用是传递给方法的一个参数时，您传递的是该引用的一个副本（按值传递），而不是引用本身。请注意，调用方法的对象引用和副本都指向同一个对象。这是一个重要区别。Java 应用程序在传递不同类型的参数时，其作法与 C++ 并无不同。Java 应用程序按值传递所有参数，这样就制作所有参数的副本，而不管它们的类型。

示例 
我们将使用前面的定义和讨论分析一些示例。首先考虑一段 C++ 代码。C++ 语言同时使用按值传递和按引用传递的参数传递机制：

清单 1：C++ 示例 

  1.  
  2. #include 
  3. #include 
  4.  
  5. void modify(int a, int *P, int &r);
  6.  
  7. int main (int argc, char** argv)
  8. {
  9.   int val, ref;
  10.   int *pint;
  11.  
  12.   val = 10;
  13.   ref = 50;
  14.   pint = (int*)malloc(sizeof(int));
  15.   *pint = 15;
  16.  
  17.   printf("val is %d/n", val);
  18.   printf("pint is %d/n", pint);
  19.   printf("*pint is %d/n", *pint);
  20.   printf("ref is %d/n/n", ref);
  21.  
  22.   printf("calling modify/n");
  23.   //按值传递 val 和 pint，按引用传递 ref。
  24.   modify(val, pint, ref);
  25.   printf("returned from modify/n/n");
  26.  
  27.   printf("val is %d/n", val);
  28.   printf("pint is %d/n", pint);
  29.   printf("*pint is %d/n", *pint);
  30.   printf("ref is %d/n", ref);
  31.  
  32.   return 0;
  33. }
  34.  
  35. void modify(int a, int *p, int &r)
  36. {
  37.     printf("in modify.../n");
  38.     a = 0;
  39.     *p = 7;
  40.     p = 0;
  41.     r = 0;
  42.     printf("a is %d/n", a);
  43.     printf("p is %d/n", p);
  44.     printf("r is %d/n", r);
  45. }

这段代码的输出为：

清单 2：C++ 代码的输出

  1.  
  2. val is 10
  3. pint is 4262128
  4. *pint is 15
  5. ref is 50
  6.  
  7. calling modify
  8. in modify...
  9. a is 0
  10. p is 0
  11. r is 0
  12. returned from modify
  13.  
  14. val is 10
  15. pint is 4262128
  16. *pint is 7
  17. ref is 0
  18.  

这段代码声明了三个变量：两个整型变量和一个指针变量。设置了每个变量的初始值并将其打印出来。同时打印出了指针值及其所指向的值。然后将所有三个变量作为参数传递给 modify 函数。前两个参数是按值传递的，最后一个参数是按引用传递的。modify 函数的函数原型表明最后一个参数要作为引用传递。回想一下，C++ 按值传递所有参数，引用除外，后者是按引用传递的。

modify 函数更改了所有三个参数的值： 

将第一个参数设置为 0。 
将第二个参数所指向的值设置为 7，然后将第二个参数设置为 0。 
将第三个参数设置为 0。

将新值打印出来，然后函数返回。当执行返回到 main 时，再次打印出这三个参数的值以及指针所指向的值。作为第一个和第二个参数传递的变量不受 modify 函数的影响，因为它们是按值传递的。但指针所指向的值改变了。请注意，与前两个参数不同，作为最后一个参数传递的变量被 modify 函数改变了，因为它是按引用传递的。

现在考虑用 Java 语言编写的类似代码：

清单 3：Java 应用程序 

  1.  
  2. class Test
  3. {
  4.   public static void main(String args[])
  5.   {
  6.     int val;
  7.     StringBuffer sb1, sb2;
  8.  
  9.     val = 10;
  10.     sb1 = new StringBuffer("apples");
  11.     sb2 = new StringBuffer("pears");
  12.     System.out.println("val is " + val);
  13.     System.out.println("sb1 is " + sb1);
  14.     System.out.println("sb2 is " + sb2);
  15.     System.out.println("");
  16.  
  17.     System.out.println("calling modify");
  18.     //按值传递所有参数
  19.     modify(val, sb1, sb2);
  20.     System.out.println("returned from modify");
  21.     System.out.println("");
  22.  
  23.     System.out.println("val is " + val);
  24.     System.out.println("sb1 is " + sb1);
  25.     System.out.println("sb2 is " + sb2);
  26.   }
  27.  
  28.   public static void modify(int a, StringBuffer r1,
  29.                             StringBuffer r2)
  30.   {
  31.       System.out.println("in modify...");
  32.       a = 0;
  33.       r1 = null;  //1
  34.       r2.append(" taste good");
  35.       System.out.println("a is " + a);
  36.       System.out.println("r1 is " + r1);
  37.       System.out.println("r2 is " + r2);
  38.   }
  39. }
  40.  

这段代码的输出为：

清单 4：Java 应用程序的输出

  1.  
  2. val is 10
  3. sb1 is apples
  4. sb2 is pears
  5.  
  6. calling modify
  7. in modify...
  8. a is 0
  9. r1 is null
  10. r2 is pears taste good
  11. returned from modify
  12.  
  13. val is 10
  14. sb1 is apples
  15. sb2 is pears taste good
  16.  

这段代码声明了三个变量：一个整型变量和两个对象引用。设置了每个变量的初始值并将它们打印出来。然后将所有三个变量作为参数传递给 modify 方法。

modify 方法更改了所有三个参数的值： 

将第一个参数（整数）设置为 0。 
将第一个对象引用 r1 设置为 null。 
保留第二个引用 r2 的值，但通过调用 append 方法更改它所引用的对象（这与前面的 C++ 示例中对指针 p 的处理类似）。

当执行返回到 main 时，再次打印出这三个参数的值。正如预期的那样，整型的 val 没有改变。对象引用 sb1 也没有改变。如果 sb1 是按引用传递的，正如许多人声称的那样，它将为 null。但是，因为 Java 编程语言按值传递所有参数，所以是将 sb1 的引用的一个副本传递给了 modify 方法。当 modify 方法在 //1 位置将 r1 设置为 null 时，它只是对 sb1 的引用的一个副本进行了该操作，而不是像 C++ 中那样对原始值进行操作。

另外请注意，第二个对象引用 sb2 打印出的是在 modify 方法中设置的新字符串。即使 modify 中的变量 r2 只是引用 sb2 的一个副本，但它们指向同一个对象。因此，对复制的引用所调用的方法更改的是同一个对象。

编写一个交换方法 
假定我们知道参数是如何传递的，在 C++ 中编写一个交换函数可以用不同的方式完成。使用指针的交换函数类似以下代码，其中指针是按值传递的：

清单 5：使用指针的交换函数 

  1.  
  2. #include 
  3. #include 
  4.  
  5. void swap(int *a, int *b);
  6.  
  7. int main (int argc, char** argv)
  8. {
  9.   int val1, val2;
  10.   val1 = 10;
  11.   val2 = 50;
  12.   swap(&val1, &val2);
  13.   return 0;
  14. }
  15.  
  16. void swap(int *a, int *b)
  17. {
  18.   int temp = *b;
  19.   *b = *a;
  20.   *a = temp;
  21. }
  22.  

 

使用引用的交换函数类似以下代码，其中引用是按引用传递的：

清单 6：使用引用的交换函数 

  1.  
  2. #include 
  3. #include 
  4.  
  5. void swap(int &a, int &b);
  6.  
  7. int main (int argc, char** argv)
  8. {
  9.   int val1, val2;
  10.   val1 = 10;
  11.   val2 = 50;
  12.   swap(val1, val2);
  13.   return 0;
  14. }
  15.  
  16. void swap(int &a, int &b)
  17. {
  18.   int temp = b;
  19.   b = a;
  20.   a = temp;
  21. }

 

两个 C++ 代码示例都像所希望的那样交换了值。如果 Java 应用程序使用“按引用传递”，则下面的交换方法应像 C++ 示例一样正常工作：

清单 7：Java 交换函数是否像 C++ 中那样按引用传递参数 

  1.  
  2. class Swap
  3. {
  4.   public static void main(String args[])
  5.   {
  6.     Integer a, b;
  7.  
  8.     a = new Integer(10);
  9.     b = new Integer(50);
  10.  
  11.     System.out.println("before swap...");
  12.     System.out.println("a is " + a);
  13.     System.out.println("b is " + b);
  14.     swap(a, b);
  15.     System.out.println("after swap...");
  16.     System.out.println("a is " + a);
  17.     System.out.println("b is " + b);
  18.   }
  19.  
  20.   public static void swap(Integer a, Integer b)
  21.   {
  22.     Integer temp = a;
  23.     a = b;
  24.     b = temp;
  25.   }
  26. }

 

因为 Java 应用程序按值传递所有参数，所以这段代码不会正常工作，其生成的输入如下所示： 

清单 8：清单 7 的输出 
before swap...
a is 10
b is 50
after swap...
a is 10
b is 50
 

那么，在 Java 应用程序中如何编写一个方法来交换两个基本类型的值或两个对象引用的值呢？因为 Java 应用程序按值传递所有的参数，所以您不能这样做。要交换值，您必须用在方法调用外部用内联来完成。

结论 
我在书中包括该信息的意图并不是作琐细的分析或试图使问题复杂化，而是想警告程序员：在 Java 应用程序中假定“按引用传递”语义是危险的。如果您在 Java 应用程序中假定“按引用传递”语义，您就可能写出类似上面的交换方法，然后疑惑它为什么不正常工作。

我必须承认，在我第一次认识到 Java 应用程序按值传递所有参数时，我也曾表示怀疑。我曾一直假定因为 Java 应用程序有两种类型，所以他们按值传递基本类型而按引用传递引用，就像 C++ 那样。在转向 Java 编程之前我已用 C++ 编程好几年了，感觉任何其他事情似乎都不直观。但是，一旦我理解了发生的事情，我就相信 Java 语言按值传递所有参数的方法更加直观。The Java Programming Language，Second Edition 的作者，Ken Arnold 和 James Gosling 在 2.6.1 节中说得最好：“在 Java 中只有一种参数传递模式 -- 按值传递 -- 这有助于使事情保持简单。”

更多技术文章，请访问我的BLOG:解惑


版权声明  
本篇文章对您是否有帮助？  投票： 是    否     投票结果：     4       3
作者其它文章：

作者全部文章     查看作者的Blog

评论人：ljumwzc 发表时间: Sat Aug 24 11:07:21 CST 2002
    愚认为Java中是对象参数是按引用（地址）传递的，请看下例：

class august
{
   int a;
   StringBuffer sb1;
  august( )
  { 
    a=10;
    sb1=new StringBuffer("你好,");
  }

}

public class saturday
{
    public static void method( august arg1)
   {
     arg1.a+=3;
     arg1.sb1.append("Java");
     System.out.println(arg1.a);
     System.out.println(arg1.sb1);
   }
  public static void main(String args[])
  {
     august Agu=new august();
     method(Agu);
     System.out.println(Agu.a);
    System.out.println(Agu.sb1);
   }

}

如果按值传递，那么输出应该是：
13
你好，Java
10
你好，

但实际在j2sdk1.4.0中输出却是：
13
你好，Java
13
你好，Java

请问，做何解释？

评论人：ljumwzc 发表时间: Sat Aug 24 11:09:24 CST 2002
    愚认为Java中是对象参数是按引用（地址）传递的，请看下例：

class august
{
   int a;
   StringBuffer sb1;
  august( )
  { 
    a=10;
    sb1=new StringBuffer("你好,");
  }

}

public class saturday
{
    public static void method( august arg1)
   {
     arg1.a+=3;
     arg1.sb1.append("Java");
     System.out.println(arg1.a);
     System.out.println(arg1.sb1);
   }
  public static void main(String args[])
  {
     august Agu=new august();
     method(Agu);
     System.out.println(Agu.a);
    System.out.println(Agu.sb1);
   }

}

如果按值传递，那么输出应该是：
13
你好，Java
10
你好，

但实际在j2sdk1.4.0中输出却是：
13
你好，Java
13
你好，Java

请问，做何解释？

评论人：JFML 发表时间: Sat Aug 24 19:23:08 CST 2002
你看看你传入method方法的参数

都不是基本类型，而是Object

所以，传入方法的其实是Ojbect引用的副本

举个例子，

我把我的银行账号（这是一个Object）给了张三

又把我的银行账号（Object副本）给了李四

张三往我的银行账号存了100$，李四也往我的银行帐号存了100$

那么你说我的银行存款现在有多少呢？

100$ ?

200$ ?

Understand ?

评论人：pinky 发表时间: Mon Aug 26 15:17:04 CST 2002
cherami，你认为 JFML的例子是否恰当。
如果对副本的改变会传回副本，从而影响对象，那样的话岂不是也实现了传引用的同样的效果
评论人：JFML 发表时间: Mon Aug 26 20:01:21 CST 2002
请仔细看看

你传入的参数是一个object

但是你在方法体内修改的不是object，而是object引用指向的一个成员变量

这就是关键所在

你体会一下两者的区别

class TTT
{
  String s;
  public TTT(String str)
  {
    s = str;
  }
}
......

TTT t = new TTT("AAA"); // 1

method(TTT t)
{
  t = new TTT("BBB"); // 2
}

// 3

这三个地方t.s的值分别是什么？

然后再看看下面

TTT t = new TTT("AAA"); // 1

method(TTT t)
{
  t.s = "BBB";    // 2
}

// 3

那么这三个地方的t.s的值分别又是什么呢？

评论人：pinky 发表时间: Tue Aug 27 12:01:29 CST 2002
你的例子我试了一下，第一种的结果是AAA BBB AAA,第二种的结果是AAA BBB BBB
这个结果也让我想清楚一些问题。对象引用的副本也是一个“指针“，他和对象的引用指向同一个区域。第一种情况下由于使用了new 语句，使副本获得一个新的指针，它指向的已不是原来的那个区域。第二种情况我还是很迷惑，因为它也实现了和c++里面一样的传引用的效果。可能我还要一段时间来想清楚这个问题。。。
评论人：JFML 发表时间: Tue Aug 27 12:49:10 CST 2002
我不懂C++

所以当时理解地还比较快：）

评论人：pinky 发表时间: Wed Aug 28 15:23:32 CST 2002
看了thinking in java 我对这个问题又有了新的认识。
传引用不一定传的就是副本，除非默认为自动生成副本
副本可以用clone生成，你也可以把自己的类创建成只读类，
或者为每个类都创建一个名为duplicate()的函数。
否则，否则不传副本，在调用方法内对对象引用的修改都最终会修改对象。
创建本地副本的目的就是防止原对象被修改。
因为能力有限，我不能把这个问题阐述的很清楚，只是提出一个观点，希望cherami 
能够再考虑一下这个问题，帮助大家把它搞清楚
评论人：jigsaw 发表时间: Thu Nov 14 18:05:11 CST 2002
How to Create a Reference to a Primitive
This is a useful technique if you need to create the effect of passing primitive
values by reference. Simply pass an array of one primitive element over
the method call, and the called method can now change the value seen by
the caller. Like this:

public class PrimitiveReference {
public static void main(String args[]) {
int [] myValue = { 1 };
modifyIt(myValue);
System.out.println(“myValue contains “ +
myValue[0]);
}
public static void modifyIt(int [] value) {
value[0]++;
}
}
//这是从sybex的complete guide里面抄来的。

评论人：kert 发表时间: Fri Nov 15 13:34:38 CST 2002
我的理解：

   我认为Java中参数的确是按值传递，然而应该如何理解参数所传递的指呢？
   我觉得可以先解释一下在Java中对象和对象的引用之间的关系！
   我们看一下的一个语句：
   
   Integer i = new Integer(1);
   在这里事实上发生了两件事，

       

  1. JVM为i分配了一个引用存放在堆栈中(暂时我们称为引用refI)     
  2. JVM实例化了对象i，在队Heap中为其分配了一个存储空间用来存放数据。并且将refI指向这个堆中的内存块。
     

   因此通常我们的传递的参数都只是这个refI，而非真正的i。
   
   因为Java是值传递，所以传递的refI是无法被改变得。而同C一样，我们可以改变refI说指向的那些数据。

  1.    
  2. public class TempTest {
  3.     static class MyInteger {
  4.         public MyInteger(int inner) {
  5.             this.inner = inner;
  6.         }
  7.  
  8.         private int inner;
  9.  
  10.         public void setInt(int i) {
  11.             inner = i;
  12.         }
  13.  
  14.         public int getInt() {
  15.             return inner;
  16.         }
  17.  
  18.         public String toString() {
  19.             return "" + inner;
  20.         }
  21.     }
  22.  
  23.     public static void swap(MyInteger a, MyInteger b) {
  24.         pl("swap");
  25.         MyInteger temp = a;
  26.  
  27.         a = b;
  28.  
  29.         b = temp;
  30.  
  31.     }
  32.  
  33.     public static void swapII(MyInteger a, MyInteger b) {
  34.         pl("swapII");
  35.         int temp = a.getInt();
  36.         a.setInt(b.getInt());
  37.         b.setInt(temp);
  38.     }
  39.  
  40.     public static void swapI(MyInteger a, MyInteger b) {
  41.         pl("swapI");
  42.         MyInteger temp = a;
  43.         a = new MyInteger(b.getInt());
  44.         b = new MyInteger(temp.getInt());
  45.     }
  46.  
  47.     public static void main(String[] args) {
  48.         MyInteger a = new MyInteger(1);
  49.         MyInteger b = new MyInteger(2);
  50.         pl(a);
  51.         pl(b);
  52.         swap(a,b);
  53.         pl(a);
  54.         pl(b);
  55.         swapI(a,b);
  56.         pl(a);
  57.         pl(b);
  58.         swapII(a,b);
  59.         pl(a);
  60.         pl(b);
  61.     }
  62.  
  63.     private static void pl(Object a) {
  64.         System.out.println(a);
  65.     }
  66. }

因此上面的例子的输出为 


1
2
swap
1
2
swapI
1
2
swapII
2
1

 

我对《Java 应用程序中的按值传递语义》的理解

看到大家在看完我转载的《Java 应用程序中的按值传递语义》反倒引起很多的争论和导致一些人越来越糊涂了，因此有必要再详细的谈谈我对这个的理解了。
以下摘自原文：

节选理解参数是按值而不是按引用传递的说明 Java 应用程序有且仅有的一种参数传递机制，即按值传递。写它是为了揭穿普遍存在的一种神话，即认为 Java 应用程序按引用传递参数，以避免因依赖“按引用传递”这一行为而导致的常见编程错误。

对此节选的某些反馈意见认为，我把这一问题搞糊涂了，或者将它完全搞错了。许多不同意我的读者用 C++ 语言作为例子。因此，在此栏目中我将使用 C++ 和 Java 应用程序进一步阐明一些事实。

要点 
读完所有的评论以后，问题终于明白了，至少在一个主要问题上产生了混淆。某些评论认为我的节选是错的，因为对象是按引用传递的。对象确实是按引用传递的；节选与这没有冲突。节选中说所有参数都是按值 -- 另一个参数 -- 传递的。下面的说法是正确的：在 Java 应用程序中永远不会传递对象，而只传递对象引用。因此是按引用传递对象。但重要的是要区分参数是如何传递的，这才是该节选的意图。Java 应用程序按引用传递对象这一事实并不意味着 Java 应用程序按引用传递参数。参数可以是对象引用，而 Java 应用程序是按值传递对象引用的。

C++ 和 Java 应用程序中的参数传递 
Java 应用程序中的变量可以为以下两种类型之一：引用类型或基本类型。当作为参数传递给一个方法时，处理这两种类型的方式是相同的。两种类型都是按值传递的；没有一种按引用传递。这是一个重要特性，正如随后的代码示例所示的那样。

在继续讨论之前，定义按值传递和按引用传递这两个术语是重要的。按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本。因此，如果函数修改了该参数，仅改变副本，而原始值保持不变。按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本。因此，如果函数修改了该参数，调用代码中的原始值也随之改变。

上面的这些是很重要的，请大家注意以下几点结论，这些都是我认为的上面的文章中的精华和最终的结论：

1、对象是按引用传递的
2、Java 应用程序有且仅有的一种参数传递机制，即按值传递
3、按值传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的一个副本
4、按引用传递意味着当将一个参数传递给一个函数时，函数接收的是原始值的内存地址，而不是值的副本

首先我们来看看第一点：对象是按引用传递的
确实，这一点我想大家没有任何疑问，例如：

  1.  
  2. class Test01 
  3. {
  4.     public static void main(String[] args) 
  5.     {
  6.         StringBuffer s= new StringBuffer("good");
  7.         StringBuffer s2=s;
  8.         s2.append(" afternoon.");
  9.         System.out.println(s);
  10.     }
  11. }

对象s和s2指向的是内存中的同一个地址因此指向的也是同一个对象。
如何解释“对象是按引用传递的”的呢？

这里的意思是进行对象赋值操作是传递的是对象的引用，因此对象是按引用传递的，有问题吗？
程序运行的输出是：
good afternoon.

这说明s2和s是同一个对象。

这里有一点要澄清的是，这里的传对象其实也是传值，因为对象就是一个指针，这个赋值是指针之间的赋值，因此在java中就将它说成了传引用。（引用是什么？不就是地址吗？地址是什么，不过就是一个整数值）

再看看下面的例子：

  1.  
  2. class Test02 
  3. {
  4.     public static void main(String[] args) 
  5.     {
  6.           int i=5;
  7.           int i2=i;
  8.           i2=6;
  9.           System.out.println(i);
  10.     }
  11. }

程序的结果是什么？5！！！
这说明什么，原始数据类型是按值传递的，这个按值传递也是指的是进行赋值时的行为。

下一个问题：Java 应用程序有且仅有的一种参数传递机制，即按值传递

  1.  
  2. class Test03 
  3. {
  4.     public static void main(String[] args) 
  5.     {
  6.         StringBuffer s= new StringBuffer("good");
  7.         StringBuffer s2=new StringBuffer("bad");
  8.             test(s,s2);
  9.         System.out.println(s);//9
  10.         System.out.println(s2);//10
  11.     }
  12.  
  13.   static void test(StringBuffer s,StringBuffer s2) {
  14.     System.out.println(s);//1
  15.     System.out.println(s2);//2
  16.     s2=s;//3
  17.     s=new StringBuffer("new");//4
  18.     System.out.println(s);//5
  19.     System.out.println(s2);//6
  20.     s.append("hah");//7
  21.     s2.append("hah");//8
  22.   }
  23. }

程序的输出是：
good
bad
new
good
goodhah
bad

为什么输出是这样的？
这里需要强调的是“参数传递机制”，它是与赋值语句时的传递机制的不同。
我们看到1,2处的输出与我们的预计是完全匹配的
3将s2指向s，4将s指向一个新的对象
因此5的输出打印的是新创建的对象的内容，而6打印的原来的s的内容
7和8两个地方修改对象内容，但是9和10的输出为什么是那样的呢？
Java 应用程序有且仅有的一种参数传递机制，即按值传递。

至此，我想总结一下我对这个问题的最后的看法和我认为可以帮助大家理解的一种方法：
我们可以将java中的对象理解为c/c++中的指针
例如在c/c++中：
int *p;

print(p);//1
*p=5;
print(*p);//2

1打印的结果是什么，一个16进制的地址，2打印的结果是什么?5，也就是指针指向的内容。
即使在c/c++中，这个指针其实也是一个32位的整数，我们可以理解我一个long型的值。

而在java中一个对象s是什么，同样也是一个指针，也是一个int型的整数（对于JVM而言），我们在直接使用（即s2=s这样的情况，但是对于System.out.print(s)这种情况例外，因为它实际上被转换为System.out.print(s.toString())）对象时它是一个int的整数，这个可以同时解释赋值的传引用和传参数时的传值（在这两种情况下都是直接使用），而我们在s.XXX这样的情况下时s其实就是c/c++中的*s这样的使用了。这种在不同的使用情况下出现不同的结果是java为我们做的一种简化，但是对于c/c++程序员可能是一种误导。java中有很多中这种根据上下文进行自动识别和处理的情况，下面是一个有点极端的情况：

  1.  
  2. class t 
  3. {
  4.   public static String t="t";
  5.     public static void main(String[] args) 
  6.     {
  7.         t t =new t();
  8.         t.t();
  9.     }
  10.         static void t() {
  11.         System.out.println(t);
  12.   }
  13. }

（关于根据上下文自动识别的内容，有兴趣的人以后可以看看我们翻译的《java规则》）
呵呵，这篇说明可能会让一些人更混乱了，但是既然写出来了就贴出来吧，不要骂我啊。
^_^

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞