复习中的新问题。请看！~

Question

1  System.out.println  调用的是toString  不信你再写别的试试
2  传的是数组的引用，不是字符串！当然会修改了！如果改成method(String s1,String s2);就象你说的那样了

Answer 1

What will happen when you attempt to compile and run the following code?
1. public class Test
2. {
3. public static void main(String args[])
4. {
5. Boolean b1 = new Boolean("Yes");//false
6. Boolean b2 = new Boolean("No");//false
7. Object obj = new Boolean(b2.equals(b1));//true
8. 
9. System.out.println(obj);
10. }
11. }
第二题
这个是静态问题，静态类的方法都是静态方法，静态在class构造的时候就分配了一块特定的内存空间

Answer 2

1.当你system.out.println(obj);的时候默认调用.obj.toString()
也就是你说System.out.println(obj.toString);
2.这个题目在于是static方法，况且c对象本身是在main里面构造的，在static main中构造的成员本身就必须已经是一个有固定内存的。这样c.method()实际上就是作了交换。

Answer 3

也就是说string args[]就是静态的。这么理解对么？

Answer 4

1，obj=new Boolean(true);
   obj的runtime type实际为Boolean,obj.toString()实际上调用的是Boolean的toString方法
这是thinking in java中RTTI的要点所在，即class Base,class Derived extends Base;
Base b=new Derived();运行时RTTI会识别出b实际上是一个Derived对象
2, 我同以superman的说法，传输组实际上是reference,和是否静态无关！

Answer 5

根据 w jsfr(令狐葱) 的说法：一. 我把程序改成：public class T2{
static Boolean a=new Boolean("dksjfs");
static Boolean b=new Boolean(true);
public static void main(String args[]){  System.out.println(a + " " + b);
}
 void method(String s[]) 
 {
 Boolean temp = a;
 a = b;
 b = temp;
 
 }

}
这样将不交换a b的值。
二. 如果改成：
 class Mystery 
 {
 public static void main(String args[]) 
 {
 Mystery c = new Mystery();
 c.method(args);
 System.out.println(args[0] + " " + args[1]);
 }
 void method(String s[]) 
 {
 String temp = s[0];
 s[0] = s[1];
 s[1] = temp;
 
 }
 }
这样会去掉那个静态内部类和方法，但是也是交换的。
可见，交换与静态方法无关。==================================================
可是，以上并不能说明全部问题。请针对以上两种修改考虑一下。还有请问：
1. args[]传递的数组是否是静态的。
2. args[]传递的数组的元素是基本的String字面值还是String的一个引用类型？

Answer 6

正如fkys（一天）所说：
值的交换与静态类是没有关系的，在java中给方法传递参数是传递的引用，所以c.method(args);
调用后会使得s和args指向同一快地址，所以在method那对值的交换会引起args那不值的交换。
也就是说在java中方法参数的传递，行参能改变实参的值

Answer 7

我又试了几个程序。
得出以下结论：
1 传递数组（无论是否是以main方法参数的形式，无论数组类型是基本类型还是引用类型对象），那么都会交换。
2 而如果不是以数组的形式，是以直接以两个对象（无论是基本类型还是引用类型）作为参数，那么都不会交换。第二个结论是我能够理解的。栈中的复制（传递）引用的交换与原来的引用无关。
可是为什么数组就能影响原来的引用？

Answer 8

String a="h",b="w";
swap(String s1,String s2 ){
  String tmp=s1;
  s1=s2;
  s2=tmp;
}
a,b是“h”,"w"的reference，a--〉"h",b->"w";
进入swap,s1->"h",s2->"w";
tmp=s1;  tmp->"h"
s1=s2;   s1-->"w"
s2=tmp;  s2-->"h"
退出函数，a,b仍是指向"h","w";
而对于数组的情况String arr[] ={"h","w"}
swap(String[] s){
  String tmp=s[0];
  s[0]=s[1];
  s[1]=tmp;
}
开始arr存储了数组元素的reference,是一个reference数组，
函数调用开始，将s指向该reference数组，对s[0]表示第一个reference，s[1]表示第二个，
tmp=s[0]; //tmp指向数组的第一个元素
s[0]=s[1];//s[0]指向第二个元素
s[1]=tmp;//s[1]也指向地一个元素；
其实改变s也就是改变了arr,arr[0]指向了第二个元素，arr[1]指向了第一个元素
欢迎楼主多多提问

Answer 9

请看此文：
http://www.cjsdn.com/post/view?bid=1&id=6374&sty=1&tpg=1&age=0根据此文的观点。
java的所有传递都是传值。基本类型传值。引用类型传递引用的复制的值。本质上都是传值。
那么为什么数组在传递时就是传递的里面对象的引用本身呢?我上过新东方的基础培训。其中的讲义讲值传递的部分我已上传到我的个人网站的一个帖子中：
http://fkys.java-cn.org/index.jsp
可以以游客身份进入。进入说吧--随便说说版面即可看到帖子。请参考它里面的举例方法。详细说明一下数组传递中在内存（栈内存和堆内存）的情况。多谢各位！~

Answer 10

引用类型传递引用的复制的值。是传的引用的地址，所以你改了引用的地址指的内容，就改变了原来引用的对象所指的值，
楼主可以看一下effictive java
有用处的，可以解释很多不明的地方

Answer 11

我觉得：
你所谓的：引用类型传递引用的复制的值。实际上就是传得所引用对象的地址嘛，（如你的讲义中很清楚的）传值还是传地址争论太多，不必非要搞出到底是传值还是地址，搞清楚到底在程序中时怎么运行就可以了！/*
 * Created on 2004-12-19
 *
 * TODO To change the template for this generated file go to
 * Window - Preferences - Java - Code Style - Code Templates
 *//**
 * @author Administrator
 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class Test {
    String[] arr={"Mouse","Mighty"};
    public void swap(String arr1[]){
     System.out.println(System.identityHashCode(arr1));
     System.out.println(System.identityHashCode(arr1[0]));
     System.out.println(System.identityHashCode(arr1[1]));
     String temp=arr1[0];
     arr1[0]=arr1[1];
     arr1[1]=temp;
     System.out.println("after swap");
     System.out.println(System.identityHashCode(arr1[0]));
     System.out.println(System.identityHashCode(arr1[1]));
     System.out.println(System.identityHashCode(arr1));
    }
public static void main(String[] args) {
Test test=new Test();
test.swap(test.arr);
System.out.println(test.arr[0]+" "+test.arr[1]);
}
}这个是测试程序，
下边是运行结果：
12014584
32099189
2917593
after swap
2917593
32099189
12014584
Mighty Mouse
也就是说arr和arr1都指向（12014584）所指向的内存，1201584指向的是一个地址数组：32099189，2917593，其中第一个地址指向了Mouse，第二个指向了Mighty
相信内存中的情形一目了然了！