Question

java 谁帮我看下这程序

public class Function
{
public static void main(String[] agrs)
{
Integer add1 = new Integer(5);
Integer add2 = new Integer(6);
Commute.commute(add1,add2);
System.out.println("函数外的：add：");
System.out.println("add1=" + add1);
System.out.println("add2=" + add2);
}
}

class Commute
{
public static void commute(Integer add1, Integer add2)
{
Integer c = null;
c = add1;
add1 = add2;
add2 = c;
System.out.println("函数中的add：");
System.out.println("add1:" + add1 + "\n" + "add2:" + add2 );
}
}
/*为什么add1 和add2 没有实现值的交换了 我的意思是在函数外的 add1 和add2 应该也和
commute 函数里面的值一样啊交换了值 编程思想是C 的通过指针引用现实值的交换！
你能帮我改下么？*/

Answer 1

虽然Java里面的类对象类似于C里面的指针，虽然我知道你是也是这么理解的，但是你上面代码最大的问题是没有理解清楚C里面函数调用时候传递指针的原理。
好比下面的C代码：
void func(int* a, int* b) {
int* c = a;
a = b;
b = c;
}

void main() {
int* a = new int(3);
int* b = new int(4);
func(a,b);
}
你觉得通过上面这段函数，*a 等于多少？ *b等于多少？
*a = 3 , *b = 4 吗？如果这样理解那就错了~~

首先你要理解函数的调用时候如果不是引用调用(C/C++特性,Java里面当然没有了）的话，那么出传递的并不是参数本身，而是参数的一个拷贝（这个可以多看一些实现原理的书）。
好比说上面的这段C++代码，虽然在main函数里面定义了a和b两个指针，但是传入的func里面的是这两个指针的拷贝（注意：虽然一个指针的拷贝和这个指针所指向的地址是相同的，但确实另外一个指针了）。如果把上面的main函数做的事情写在同一个函数里面的话，如下：
void main() {
int* a = new int(3);
int* b = new int(4);
//相当于调用func的时候参数的复制
int* a_copy = a;
int* b_copy = b;
// func的内容了
int* c = a_copy;
a_copy = b_copy;
b_copy = c;
}
这样是不是会清楚很多啊？执行完毕之后，a和b以及a所指向的内容和b所指向的内容并不会发生本质的变化。如果还不是很清楚，那我画个简单的图来说说吧：
指针************值
a-------------->|3|
copy_a ----------|

b-------------->|4|
copy_b ----------|

当你调用
int* c = copy_a;
copy_a = copy_b;
copy_b = c;
的时候，我们应该清楚，指针记录的是“指针”，是指向的地址，而不是地址里面的值。那么你交换指针的值，其实只是交换了指针所指向的地址。那么执行完上面那两步之后，指针的状态应该为：
指针************值

a-------------->|3|
copy_b ----------|

b-------------->|4|
copy_a ----------|

看到了吧，a和b所指向的内容并没有发生本质的变化。

你的意思我了解，你是想交换a所指向的值和b所指向的值是吧？那代码就应该这么些：
void main() {
int* a = new int(3);
int* b = new int(4);
//相当于调用func的时候参数的复制
int* a_copy = a;
int* b_copy = b;
// func的内容了
int c = *a_copy;
*a_copy = b_copy;
int* b_copy = c;
}

因为*a_copy代表的是a_copy所指向的地址的内容，注意是内容，所以做完上面的交换之后，指针状态是：
指针*************值
a-------------->|4|
copy_a ----------|

b-------------->|3|
copy_b ----------|

看到了吧，交换了copy_a和copy_b所指向的地址中保存的值，也就交换了a和b所指向的地址中保存的值。
那么还原为函数的话就应该写成：
void func(int* a, int* b) {
int c = *a;
*a = *b;
*b = c;
}

void main() {
int* a = new int(3);
int* b = new int(4);
func(a,b);
}

嗯嗯，想必写到这里，你应该对C++的指针有一个更加清楚的了解了吧。
那么接下来，我再来纠正你对Integer的一个误区。没错，Java里面的类对象和C++里面的指针（当然包括类对象指针）是很相似的，比如你新建一个类A
Class A{}
那么 A a = new A();的确可以理解为a为一个A对象的指针；但是这样的理解要除去若干特殊的类，例如Integer、Long、Short这类叫做包装器的类型。Java里面为了可以将基本类型（int,long,double)这类基本类型当作一般的类来用，特地开发了一套对应的包装器类型。但是需要注意的是：Java开发这类包装器的原意只是为了让你像使用一般类型一样的使用基本类型，当然的，你使用包装器类型也像使用基本类型一样。如果你看过Integer的源代码的话，你会发现虽然在Integer类中有一个int型的成员变量，你每在写Integer a = new Integer(3)的时候可以将这个成员变量赋值成3，但是Integer却没有提供任何其他的函数使你可以将这个成员变量改变成其它的值。说白了，就是当你把一个Integer的成员变量new出来之后，他所指向的地址中的内容就固定了。再说的浅显直白一些，Java只是希望你再用Integer的时候和用int的时候一模一样。所以你在提问中写的函数和下面的函数功效是一样的-____-:
public class Function
{
public static void main(String[] agrs)
{
int add1 = 5;
int add2 = 6;
Commute.commute(add1,add2);
System.out.println("函数外的：add：");
System.out.println("add1=" + add1);
System.out.println("add2=" + add2);
}
}

class Commute
{
public static void commute(int add1, int add2)
{
int c ;
c = add1;
add1 = add2;
add2 = c;
System.out.println("函数中的add：");
System.out.println("add1:" + add1 + "\n" + "add2:" + add2 );
}
}

显然上面的函数是不满足你的需求的。呵呵，不过别担心，如果你真的有这种需求的话，那么我们可以按照你对Java一般类对象的理解来写一个一般的类：
class Int {
int value;

public Int(int v) {
value = v;
}

public int get() {
return value;
}

public void set(int v) {
value = v;
}
}
用这个自定义的Int来写函数的话。。。
public class Function {
public static void main(String[] agrs) {
Int add1 = new Int(5);
Int add2 = new Int(6);
Commute.commute(add1, add2);
System.out.println("函数外的：add：");
System.out.println("add1=" + add1.get());
System.out.println("add2=" + add2.get());
}
}

class Commute {
public static void commute(Int add1, Int add2) {
int c = add1.get();
add1.set(add2.get());
add2.set(c);
System.out.println("函数中的add：");
System.out.println("add1:" + add1.get() + "\n" + "add2:" + add2.get());
}
}

上面的代码就是了，如果觉得get，set不足以让你理解的话，那么。。。
class Int {
public int value;

public Int(int v) {
value = v;
}
}

public class Function {
public static void main(String[] agrs) {
Int add1 = new Int(5);
Int add2 = new Int(6);
Commute.commute(add1, add2);
System.out.println("函数外的：add：");
System.out.println("add1=" + add1.value);
System.out.println("add2=" + add2.value);
}
}

class Commute {
public static void commute(Int add1, Int add2) {
int c = add1.value;
add1.value = add2.value;
add2.value = c ;
System.out.println("函数中的add：");
System.out.println("add1:" + add1.value + "\n" + "add2:" + add2.value);
}
}

这样似乎更直白一些。不过理解归理解，Java里面最好还是将成员变量封装成private或者protected的好一些，要不然java也没啥好炫耀的了-_-
////////////////////////////
ok，说了这么多，希望java这些诡异的特性不会打消你学习Java的热情-______-

Answer 2

我的理解是，就算是地址传递，也只是把方法外面的变量地址传递给方法内部，并且让，方法参数指向该地址，交换的是引用并不是地址
所以说 参数的add1 和add2 并不是方法外定义的那2个东东

Answer 3

JAVA 是按值传递的
你在类Commute中的方法通过设置它的参数值返回值^
这根本不会起作用的 因为add1,add2只是在方法commute的范围内存在,返回时,这些变量将消失,对它们的所有改变都丢失了.
要改的话,可以通过对方法范围外的一个对象的引用,所以在方法中对对象做的修改在方法返回后仍然存在

public class Function
{
public static void main(String[] agrs)
{ IntegerSet s=new IntegerSet();
s.add1=new Integer(5);
s.add2=new Integer(6);
Commute.commute(s);
System.out.println("函数外的add：");
System.out.println("add1=" + s.add1);
System.out.println("add2=" + s.add2);
}
}

class Commute
{
public static void commute(IntegerSet f)
{
Integer c = null;
c = f.add1;
f.add1 = f.add2;
f.add2 = c;
System.out.println("函数中的add：");
System.out.println("add1:" + f.add1 + "\n" + "add2:" + f.add2 );
}
}
class IntegerSet {
public Integer add1;
public Integer add2;
}