因为another中的tv是指向对象的
tv.i = 20;
改变了该对象的属性。
而tv=th;是修改了指针的值，对tv原来指向的对象没有任何影响。
在这一点上，和C是一样的。
换句话说，除了简单的值类型和String等之外，java的参数也是地址传递。
tv.i = 20;
改变了该对象的属性。
而tv=th;是修改了指针的值，对tv原来指向的对象没有任何影响。
在这一点上，和C是一样的。
换句话说，除了简单的值类型和String等之外，java的参数也是地址传递。
Java 应用程序中的按值传递语义
几个月前，developerWorks 发布了我的书 Practical Java 中的一些节选，该书是由 Addison-Wesley 出版的。首先我将利用 developerWorks 上的此栏目回答读者提出的一些问题，然后对有关这些节选的各种评论作一答复。节选理解参数是按值而不是按引用传递的说明 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++ 示例 #include
#include void modify(int a, int *P, int &r);int main (int argc, char** argv)
{
int val, ref;
int *pint; val = 10;
ref = 50;
pint = (int*)malloc(sizeof(int));
*pint = 15; printf("val is %d\n", val);
printf("pint is %d\n", pint);
printf("*pint is %d\n", *pint);
printf("ref is %d\n\n", ref); printf("calling modify\n");
//按值传递 val 和 pint，按引用传递 ref。
modify(val, pint, ref);
printf("returned from modify\n\n"); printf("val is %d\n", val);
printf("pint is %d\n", pint);
printf("*pint is %d\n", *pint);
printf("ref is %d\n", ref); return 0;
}void modify(int a, int *p, int &r)
{
printf("in modify...\n");
a = 0;
*p = 7;
p = 0;
r = 0;
printf("a is %d\n", a);
printf("p is %d\n", p);
printf("r is %d\n", r);
}
这段代码的输出为：清单 2：C++ 代码的输出 val is 10
pint is 4262128
*pint is 15
ref is 50calling modify
in modify...
a is 0
p is 0
r is 0
returned from modifyval is 10
pint is 4262128
*pint is 7
ref is 0
这段代码声明了三个变量：两个整型变量和一个指针变量。设置了每个变量的初始值并将其打印出来。同时打印出了指针值及其所指向的值。然后将所有三个变量作为参数传递给 modify 函数。前两个参数是按值传递的，最后一个参数是按引用传递的。modify 函数的函数原型表明最后一个参数要作为引用传递。回想一下，C++ 按值传递所有参数，引用除外，后者是按引用传递的。modify 函数更改了所有三个参数的值： 将第一个参数设置为 0。
将第二个参数所指向的值设置为 7，然后将第二个参数设置为 0。
将第三个参数设置为 0。将新值打印出来，然后函数返回。当执行返回到 main 时，再次打印出这三个参数的值以及指针所指向的值。作为第一个和第二个参数传递的变量不受 modify 函数的影响，因为它们是按值传递的。但指针所指向的值改变了。请注意，与前两个参数不同，作为最后一个参数传递的变量被 modify 函数改变了，因为它是按引用传递的。现在考虑用 Java 语言编写的类似代码：清单 3：Java 应用程序 class Test
{
public static void main(String args[])
{
int val;
StringBuffer sb1, sb2; val = 10;
sb1 = new StringBuffer("apples");
sb2 = new StringBuffer("pears");
System.out.println("val is " + val);
System.out.println("sb1 is " + sb1);
System.out.println("sb2 is " + sb2);
System.out.println(""); System.out.println("calling modify");
//按值传递所有参数
modify(val, sb1, sb2);
System.out.println("returned from modify");
System.out.println(""); System.out.println("val is " + val);
System.out.println("sb1 is " + sb1);
System.out.println("sb2 is " + sb2);
} public static void modify(int a, StringBuffer r1,
StringBuffer r2)
{
System.out.println("in modify...");
a = 0;
r1 = null; //1
r2.append(" taste good");
System.out.println("a is " + a);
System.out.println("r1 is " + r1);
System.out.println("r2 is " + r2);
}
}
这段代码的输出为：清单 4：Java 应用程序的输出 val is 10
sb1 is apples
sb2 is pearscalling modify
in modify...
a is 0
r1 is null
r2 is pears taste good
returned from modifyval is 10
sb1 is apples
sb2 is pears taste good
这段代码声明了三个变量：一个整型变量和两个对象引用。设置了每个变量的初始值并将它们打印出来。然后将所有三个变量作为参数传递给 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：使用指针的交换函数 #include
#include void swap(int *a, int *b);int main (int argc, char** argv)
{
int val1, val2;
val1 = 10;
val2 = 50;
swap(&val1, &val2);
return 0;
}void swap(int *a, int *b)
{
int temp = *b;
*b = *a;
*a = temp;
}
使用引用的交换函数类似以下代码，其中引用是按引用传递的：清单 6：使用引用的交换函数 #include
#include void swap(int &a, int &b);int main (int argc, char** argv)
{
int val1, val2;
val1 = 10;
val2 = 50;
swap(val1, val2);
return 0;
}void swap(int &a, int &b)
{
int temp = b;
b = a;
a = temp;
}
两个 C++ 代码示例都像所希望的那样交换了值。如果 Java 应用程序使用“按引用传递”，则下面的交换方法应像 C++ 示例一样正常工作：清单 7：Java 交换函数是否像 C++ 中那样按引用传递参数 class Swap
{
执行后vh.i = 10;
tv = vh;
相当于tv与vh是同一个指针，所以tv.i = 10;
所以我觉得是
10 0
10
而不是
10 0
20 //20从何而来？
20是从你的another方法中得来的，因为Java完全是按引用传递，所以你在another方法中的那次tv.i = 20;赋值就使得你得到了20，我劝你还是先看看上面那段话吧！
class TestValue {
public int i = 10;
}
public class TestField {
public static void main(String argv[]){
TestField tf = new TestField();
tf.amethod();
}
public void amethod(){
int i = 99;
TestValue tv = new TestValue();
tv.i = 30;
another(tv,i);
System.out.println(tv.i);
}
public void another(TestValue tv, int i){
i = 0;
//tv.i = 20;
tv.i=10;
//TestValue vh = new TestValue();
//tv = vh;
System.out.println(tv.i+ " "+i);
}
}
运行结果是
10 0
10 //这样，是不是原因就清楚了！！？？
class TestValue {
public int i = 10;
}
public class TestField {
public static void main(String argv[]){
TestField tf = new TestField();
tf.amethod();
}
public void amethod(){
int i = 99;
TestValue tv = new TestValue();
tv.i = 30;
//**
System.out.println("first:"+tv);
another(tv,i);
System.out.println("three:"+tv);
System.out.println(tv.i);
}
public void another(TestValue tv, int i){
i = 0;
//tv.i = 20;
//tv.i=10;
TestValue vh = new TestValue();
tv = vh;
System.out.println("second:"+tv);
System.out.println(tv.i+ " "+i);
}
}
大家看一看这程序又是什么结果？
为什么这会这样??
哈哈－－－哈哈！！！
first:TestValue@82f0db
second:TestValue@92d342
10 0
Three:TestValue@82f0db
很显然another（）中对象tv指的位置变了！！！
tv = vh;而改变的。
进入anohter后，传给another 的tv,是此方法内新建的一个变量，这个变量最初被赋为amethod内的tv地址，相当于another的指针与amethod的tv指针同时指向同一个实例，
此时实例的i变量被赋值，后来，another的tv又被new的Tv赋值，两个tv就指向不同的实例了，another运行结束后，当前的tv还指向原来那个实例。
修改副本，等同于修改原件指向的地址空间中的内容。如：
anthor()中的tv.i=20;
重新赋值副本，等同于把副本指向新的地址空间，此时副本和原件指向向不同的地址空间。如：
anthor()中System.out.println(tv.i+ " "+i);语句的tv（指向vh的地址空间）与amethod()中System.out.println(tv.i);语句的tv（仍然指向调用anthor()前tv的地址空间）指向不同的地址空间。
================================================================CSDN 论坛助手 Ver 1.0 B0402提供下载。 改进了很多，功能完备！★ 浏览帖子速度极快！[建议系统使用ie5.5以上]。 ★ 多种帖子实现界面。
★ 保存帖子到本地[html格式]★ 监视您关注帖子的回复更新。
★ 可以直接发贴、回复帖子★ 采用XML接口，可以一次性显示4页帖子,同时支持自定义每次显示帖子数量。可以浏览历史记录！
★ 支持在线检测程序升级情况，可及时获得程序更新的信息。★★ 签名 ●
可以在您的每个帖子的后面自动加上一个自己设计的签名哟。Http://www.ChinaOK.net/csdn/csdn.zip
Http://www.ChinaOK.net/csdn/csdn.rar
Http://www.ChinaOK.net/csdn/csdn.exe [自解压]
这是java里面最模糊的概念。