一道关于值传递的题?

Question

package d;public class X { public static void main(String[] args) {
String str="abc";
str+="de";
System.out.println("str="+str);//str=abcde
modify(str);
System.out.println("str="+str);//str=abcde
} public static void modify(String s) {
s+="fg";
}
}既然modify()的运行不能改变str的值,那么为什么在方法外就可以改变了.我知道str+="de",str的值肯定会变,但是,为什么在方法体内就不能改变了呢?

Answer 1

public static void modify(String s) {
        s+="fg";
    }
实参的变量能当形参用?
public static void modify(String s) {
        str=s + "fg";
    }我还是菜鸟,说得不对请包涵.

Answer 2

java是值传递，
public class Test{
public static void main(String[] args) {
Bean bean = new Bean();
List<String> list = new ArrayList<String>();
list = bean.getList();
list.add("test1"); for (String str : bean.getList()) {
System.out.println(str);
}
}
}
class Bean { private List<String> list = new ArrayList<String>(); public Bean() {
list.add("test0");
} public List<String> getList() {
return list;
} public void setList(List<String> list) {
this.list = list;
}
}

Answer 3

因为String是mutiable的啊，用StringBuilder或StringBuffer    public static void main(String[] args) {
        StringBuilder str=new StringBuilder("abc");
        str.append("de");
        modify(str);
        System.out.println("str="+str);//str=abcde
        }        public static void modify(StringBuilder s) {
            s.append("fg");
        }

Answer 4

public class X { public static void main(String[] args) {
String str = "abc";
str += "de";
System.out.println("str=" + str);// str=abcde
modify(str);
System.out.println("str=" + str);// str=abcde
} public static void modify(String s) {
s += "fg";//此处的s是modify函数中的形参
//s+="fg" 相当于  "abc"+"fg";

//根据局部变量作用域可知：modify方法执行完后.s变量内存被回收
//也可以通过另一观点证明：modify(str);此处传递的是str的值而不是指针。相当于c中的值传递。可知
//main方法中的str值并没有被修改。完毕：）
}

Answer 5

这里你传的时字符串的引用！！！！！字符串时不可变的，，，，str的指向这里时不会改变的，而这里的s的指向会改变

Answer 6

这个一方面是由于String的特殊性.s+="55";
这里会产生新的对象.就是说与原来的无关了.所以你无法改变传进来的对象,你只是把传进来的对象加上另一个字符串,产生新的对象.你只是利用了一下原来的对象,而无法改变原来的对象.

Answer 7

这里你传的时字符串的引用！！！！！字符串时不可变的，，，，str的指向这里时不会改变的，而这里的s的指向会改变，
他们说得很好了。

Answer 8

两点：首先这里传递的是String s的引用，相当于String s1 = s；然后将s1传进去，s1和s都指向同一块内存区域，
另外，String 类型是不可变的，s+="fg";相当于将s指向的内存值取出来和"fg”连接起来"abcdefg”，又开辟一块内存区域将他存进去，将"abcdefg”用这个引用s指向他，此处的s实际上是s1，而s本身并没有变，要想得到"abcdefg”，只有return s；其他类型的类传递的也是引用，但可以通过这个引用改变里面的属性值，因为不存在不可变的性质，仔细看哈String类

Answer 9

String 对象是 一个不可修改的对象，String对象 的 任何方法，都不会改变其自身的。

Answer 10

这个问题我还是理解不可以（可以参考）
String 类型传入方法是引用传递（注：基本类型传递是复制传递），
   public static void main(String[] args) {
    String str="abc";
    str+="de";//注意：此时引用str指向了另一个值为“abcde”的内存地址，而原来值为“abc”内存地址没有了引用，将被GC回收
    System.out.println("str="+str);//str=abcde
    modify(str);
    System.out.println("str="+str);//str=abcde
    }    public static void modify(String s) {//这里将引用传递到方法里，如果在方法里对引用指向的原对象（原内存地址）的改变会影响到原对象，但是对新对象（新内存地址）不会影响原对象，即使在方法体内将引用指向了其他对象，当退出时传入的引用仍然指向原对象。
        s+="fg";
       //这里也是创建了一个新String,并且将传入引用s指向它，但整个过程没有改变原String对象（内存地址的内容），当然这里也不可能改变原对象，因为String是immutable.
    }给你一个更普遍的引用传递例子，你分析哈（转SCJP 学习笔记 for 1.4）
class ValHold{
    public int i = 10;
}
public class ObParm{
    public void amethod(){
            ValHold v = new ValHold();
            another(v);
            System.out.println(v.i);
    }
public void another(ValHold v){
            v.i = 20;
            ValHold vh = new ValHold();
            v =vh;
            System.out.println(v.i);
}
public static void main(String[] argv){
            ObParm o = new ObParm();
            o.amethod();//输出是10，20
}
}

Answer 11

java中都是值传递！
只是对于不同类型的数据：
基本数据就是值本身。
引用类型这个值就是这个引用。
所以此题中，传到方法中的这个值是str这个引用的拷贝
所以尽管拷贝的那个引用所对应的值改变了但是原来的str并没有改变。

Answer 12

package d;public class X {    public static void main(String[] args) {
    String str="abc";
    str+="de";
    System.out.println("str="+str);//str=abcde
    modify(str);
    System.out.println("str="+str);//str=abcde
    }
    public static void modify(String s) {
        s+="fg";
    }}
我说说我的看法，我觉得是作用域的关系，你是在红色区域system.out.println，也就是说你打印出的根本就不是你调用下面方法里的a，而是在上面的a。下面的a出了它那个作用域就不认识了。
呵呵，不知道这样理解对不对，望高手指正，重在参与。

Answer 13

你可以把
public static void modify(String s) { 
        s+="fg"; 
    }} 
里的String s 改为其他的字母比如m然后 m+=“fg”再编译 ，你会看到编译报错，说根本就没m这个变量

Answer 14

在调用方法的时候方法里面会新建一个引用类型s
s和str指向同一个String对象
但是在方法里面执行这一句之后 s+="fg";
s就指向了一个新的对象 "abcdefg"
而str仍然指向原来的String对象"abcde"
方法调用结束后
s失去作用
回到main方法里面
调用的还是str
这时候当然打印出来的还是原来的值