2个题搞得有点糊涂
Exhibit:
1. public class X {
2. public static void main (String[]args) {
3. string s = new string (“Hello”);
4. modify(s);
5. System.out.printIn(s);
6. }
7.
8. public static void modify (String s) {
9. s += “world!”;
10. }
11. }
What is the result?
E. The program runs and prints “Hello”
F. An error causes compilation to fail.
G. The program runs and prints “Hello world!”
H. The program runs but aborts with an exception.
Answer: A
Exhibit:
1. public class X {
2. public static void main (String[]args) {
3. int [] a = new int [1]
4. modify(a);
5. System.out.printIn(a[0]);
6. }
7.
8. public static void modify (int[] a) {
9. a[0] ++;
10. }
11. }
What is the result?
A. The program runs and prints “0”
B. The program runs and prints “1”
C. The program runs but aborts with an exception.
D. An error “possible undefined variable” at line 4 causes compilation to fail.
E. An error “possible undefined variable” at line 9 causes compilation to fail.
Answer: B
希望能够详细说说，希望把知识点说到
[解决办法]
1.String类型的对象是常量,不可以被更改
2.当定义一个int数组时,如果未被赋值,则默认值为0,a[0]++,以后a[0]的值就变为1
[解决办法]
两者传递的都是对象的引用，两个方法都没有改变原来的对象的引用指向，但是第一个由于java中的String是final的，所以s += “world!”会创建一个新的String对象，对原来对象的内容没有改变，第二个则改变了对象的内容。
[解决办法]
看《javw2全方位学习》里面有详细解答
[解决办法]
这两道题的实质是考察参数传递。所有参数的传递都是对象副本的引用。
先看第一题：
string s = new string (“Hello”);将s传递给方法 modify其实将s的副本传递给了方法 modify。在方法 modify中， s += “world!”;这个s不是string s = new string (“Hello”);中的s。 s += “world!”;中的s其实string s = new string (“Hello”);的副本，所以的它的改变不会影响对象本质的改变。所以已经是Hello。
第二题：
int [] a = new int [1]，树组a传递给方法modify(a);而方法modify中a[0] ++;此时的a[0]就变成了1。因为通过a[0] ++;在int [] a = new int [1]中，对象a已经是实质的改变。
也许这样的回答LZ还不能明白，最好看看传输传递这一章
[解决办法]
java只有参数传值调用，所以A无法改变String对象的值；
然而数组比较特殊，在参数传递过程中是传地址，所以值发生了变化。
[解决办法]
第一个很好理解...
JAVA中..函数传递的都是对象的副本,是值传递.没有传递地址,即 改变的只是在modify方法中新建的s,main下的s并没有改变 .沙发上说string出来的是常量比较搞笑
第二个我也没整明白...上面有人解释得无法自圆其说
按理说JAVA中的传递都是对象的副本传递.....
[解决办法]
第二題的詳細解釋是什麽呀
[解决办法]
1.String类型的对象是常量,不可以被更改
2、对于对象类型，也就是Object的子类，如果你在方法中修改了它的成员的值，那个修改是生效的
[解决办法]
public class Test {
public static void main(String[] args) {
String s = new String( "Hello ");
modify(s);
System.out.println(s);
}
public static String modify(String s1) {
s1 += "world! ";
return s1;
}
}
结果 helloworld
hello
[解决办法]
二.int 值的初始化值为0,大家了解.
一.我刚开始也迷糊一下认为string是不可改变的,会报错才对.
string不是对像吗?对像传递应该都是地址传递才对吧.
[解决办法]
第一题你确定答案没错？在打印的时候s的引用已经由modify方法改变了！因为s+=“world”与s=s+“world”是一个公式！所以在此时s的引用已经被重定向为指向常量hello world！了！打印的话应该打印出hello world的！
第二题你声明了一个只含有一个元素的int类型数组！而int类型的数组你在未赋值的时候它默认为0！后面由modify方法给其加1！所以它的值是1！int数组里面所有的元素都是int类型的！也就是基本数据类型！它跟string不一样！它是把值直接存在数组i[0]的内部而不是引用！
[解决办法]
首先要明确一点 String 是 字符串常量 StringBuffer才是变量
还有就是字符串的连接问题 上题中 不能用常量再去连接另一个字符串 用一个新字符串去连接的话 就行了．
[解决办法]
学习中ing....
[解决办法]
看着我都晕 不是说对象是传址么
String 类型的不也是对象么 怎么它就是传值？
[解决办法]
学习
[解决办法]
偶来公布答案：
明确两点就可以了：
1、Java里函数调用确实传的是引用的副本。
2、数组这个东西在java虚拟机内部是被当作一个对象的。int a[] 被表示为[int
所以，第一题，传的是一个对象引用的副本，modify内部将这个副本指向了新对象“helloworld”,但是，S的本尊一点没变！还是指向“Hello”。
第二题，传的也是一个对象引用的副本。但这次modify修改的是这个引用指向的对象。所以a[0]被修改了。
鉴定完毕。
[解决办法]
s += “world!”;
========================
需要注意的是，在modify(String s)方法里面的s和main()方法里的s是两个不同的内容，在调用modify()方法的时候，是先复制了s的一个拷贝给modify()方法，然后对这个拷贝进行运算，实际上操作的内容并不是main()中的s，所以最后打印出来的就只是 "hello "
==============================
a[0] ++;
================================
在modify()方法中使用的a[0]是一个基本数据类型，而不是一个引用类型的变量，所以在操作的时候，是直接传值给modify()方法（并不是用其拷贝），然后通过modify()方法改变它在内存地址中的值。
========================================
关于为什么基本数据类型是传值而饮用类型变量是拷贝，这跟他们在内存中的存储方式不同有关，具体可以翻阅资料。
[解决办法]
两者传递的都是对象的引用，两个方法都没有改变原来的对象的引用指向，但是第一个由于java中的String是final的，所以s += “world!”会创建一个新的String对象，对原来对象的内容没有改变，第二个则改变了对象的内容。
同意这个观点
[解决办法]
两者传递的都是对象引用的拷贝，拷贝，就是说和引用指向的是同一个地方，但是它不是引用。
在第一个modify(s)：我们假设s的引用拷贝为S1，这样s和S1指向的是同一块地方。
但是在modify(）内部，由于s += “world!”，相当于S1+= "world "，结果就是S1指向了另外一个地方，并没有改变s的值。
而对于第二种情况，改变的是引用拷贝所指向的那块地方的值－而引用也是指向这个地方的，于是就改变了引用“指向”的值，所以modify（）之后，其值会改变。
这两个问题是一般性的问题，与是String，Char无关的。
看看下边的例子吧。
＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
public class TestReffrenceCopy {
public static void main(String args[]) {
MyObject obj1 = new MyObject();
MyObject obj2 = new MyObject();
obj1.number = 1;
obj2.number = 1;
changeNumber1(obj1);
changeNumber2(obj2);
System.out.println( "After changing, obj1.number is: " + obj1.number);
System.out.println( "After changing, obj2.number is: " + obj2.number);
}
public static void changeNumber1(MyObject obj) {
obj.number = 100;
}
public static void changeNumber2(MyObject obj) {
MyObject newObj = new MyObject();
newObj.number = 100;
obj = newObj; //It only changes the refference-copy 's value.
}
}
class MyObject {
public int number;
}
===============================================
结果是：
After changing, obj1.number is: 100
After changing, obj2.number is: 1
