为什么运行结果是1234.请详细解答

Question

public class Test { 
public static void changestr(String str){ 
    
      str="welcome"; 
     } 
     public static void main(String[] args) { 
      String str="1234"; 
      changestr(str); 
      System.out.println(str); 
   }
}

Answer 1

 String str="1234"; 
 changestr(str); 
System.out.println(str); 
java传递的是拷贝，进changestr时，传递一份str的拷贝进去.
进去后你又将拷贝的值改为welcome，但并没有影响到str的原值12134

Answer 2

如果传递的是可变对象的拷贝，那么拷贝指向原堆的内存空间，这时会影响到原对象值
如下面的例子public static void main(String[] args){
        Map<String, String> map = new HashMap<String, String>();
        map.put("a", "123");
        map.put("b", "234");
        System.out.println(map.size());
        changeMap(map);
        System.out.println(map.size());
    }
    
    public static void changeMap(Map map) {
        map.put("c", "345");
    }得到
2
3

Answer 3

这个和C中式一致的，这是个作用域的问题，在函数changestr中你执行的是局部变量strshi channgestr里面的局部变量。
这个str和main中的str是两个不同的局部变量。其实按这个changestr的函数，不管你传入什么字符串，changestr里的str的值都是
welcome，但是当changestr执行完之后chengestr里的局部变量就失效了。所以当你出来changestr到main里试产str时，这个str其实是main里的str，那当然是你定义的str=1234的咯，，，，如果你在changestr里试产str 话就是welcome了。

Answer 4

java 值引用传递的问题~你可以去查查的~

Answer 5

java中参数传递有两种，一种是值传递，一种是引用传递。你用的就是值传递。只是把str的值传递进去了，不会改变他本事。如果是引用传递，那么传递进去就会改变。比如，传递一个list集合等等都是引用传递！！！！

Answer 6

java的函数，值是不会传递过去的，如果你在changestr函数里打System.out.println(str);    就会输出welcome。函数完结的时候，里面的值就会没有，在main函数里的值还是1234

Answer 7

java是值传递。只有修改了当前存储地址内的值，输出才会有变化

Answer 8

建议楼主看看Java参数传递这方面的资料

Answer 9

执行完changestr方法之后str仍然对应字符串"1234"

Answer 10

这个是java，String变量的赋值有关系的，不要认为所有java对象的赋值都是传地址的。
String x = "111"; 等同于String x = new String("111");
String变量的赋值永远是new个新对象。

Answer 11

你如果传入的StringBuffer,是会改变外面的值的。
例如
public class Test { 
 public static void changestr(StringBuffer str){
      str.setLength(0);
      str.append("welcome");
     }
   public static void main(String[] args) {
      StringBuffer str=new StringBuffer("1234");
      changestr(str);
      System.out.println(str);
   }
}打印出来的值就是变成welcome;

Answer 12

String作为一个类与别的类很大不同，因为他是与int之类的简单类型一样，是值传递的。

Answer 13

public static void main(String[] args) { 
      String str = "1234"; 
      str = changestr(str); 
      System.out.println(str); 
   }楼主应该是这个意思

Answer 14

 class LTest{
String str;
private static LTest L=new LTest();
private LTest(){}
public static LTest getInstance(){
return L;
}
public void changstr(String str){
this.str="welcome";
}
}
public class Test{       
        public static void main(String[] args) {
      LTest L1=LTest.getInstance();
      L1.str="1234";
      L1.changstr(L1.str);
        System.out.println(L1.str);
   }
}
//这跟单例模式相同，加个类，问题解决。

Answer 15

楼上那么多东拉西扯的道理一大堆什么参数传递、值传递等等。
知道string是使用类修饰符final修饰的么。final意思是什么？

Answer 16

你如果不要changestr那个函数那么就会得到你想要的结果
你可以直接在main函数中写str="welcome"最后输出的结果就是你最后一次赋值的结果那么这是为什么呢？因为你只是将值传给了函数，你函数中的str只是一个变量，并不影响主函数中的结果

Answer 17

http://bbs.csdn.net/topics/390784895

Answer 18

changestr(str);  中的 str是局部变量  

Answer 19

你这个只是传值过去
 没有改变str本身的值

Answer 20

所谓值传递，就是说仅将对象的值传递给目标对象，就相当于copy；系统将为目标对象重新开辟一个完全相同的内存空间。
所谓引用，就是说将对象在内存中的地址传递给目标对象，就相当于使目标对象和原始对象对应同一个内存存储空间。此时，如果对目标对象进行修改，内存中的数据也会改变。
值传递，例如：
class TestT1 
{ 
public static void main(String[] args) 
{ 
int i = 5; 
int j = 6; 
System.out.println("before exchange i = "+i);//交换前
exchange(i, j); 
System.out.println("after exchange i = "+i);//交换后
}
public static void exchange(int a,int b) 
{ 
int k;
k = a;a = b; b = k; 
} 
} 程序的结果是5！！！ 
这说明，原始数据类型是按值传递的，这个按值传递也是指的是进行赋值时的行为。 
Java语言明确说明取消了指针，因为指针往往是在带来方便的同时也是导致代码不安全的根源，同时也会使程序的变得非常复杂难以理解，但这只是在Java语言中没有明确的指针定义，实质上每一个new语句返回的都是一个指针的引用。
引用传递，例如：
class TestT2
{ 
public static void main(String[] args) 
{ 
StringBuffer s= new StringBuffer("good"); 
StringBuffer s2=s; 
s2.append(" afternoon."); 
System.out.println(s); 
} 
} 对象s和s2指向的是内存中的同一个地址因此指向的是同一个对象。 
这里的意思是进行对象赋值操作是传递的是对象的引用，因此对象是按引用传递的。 
程序运行的输出是： 
good afternoon. 
这说明s2和s是同一个对象。
总结： 
大家都知道，在JAVA中变量有以下两种：
基本类型变量，包括boolean、byte、char、short、int、long、float、double。
引用类型变量，包括类、接口、数组（基本类型数组和对象数组）。
对于基本类型和基本类型变量被当作参数传递给方法时，是值传递。在方法实体中，无法给原变量重新赋值，也无法改变它的值。
而对象作为参数，如果在方法中把对象作为参数，方法调用时，参数传递的是对象的引用，即在方法调用时，实际参数把对对象的引用传递给形式参数。这是实际参数与形式参数指向同一个地址，即同一个对象，方法执行时，对形式参数的改变实际上就是对实际参数的改变，这个结果在调用结束后被保留了下来。

Answer 21

你写的代码里面有两个str，一个是main方法里面的，另一个是changestr方法里面的。
你在main里面调用changestr，是将main里的str赋值给changestr里面的str，然后改变的是changestr里的str，而main里的str没有改变，仍旧是1234，所以输出的是1234。

Answer 22

楼主之所以不理解为什么结果是1234，是因为楼主没有理解值传递、引用传递、局部变量的概念。
用final修饰的量是常量，一旦给定一个值，以后就无法改变（就是只能赋值一次，以后就不能变了）。

Answer 23

public class Test { 
public static String changestr(String str){ 
    
      str="welcome";
      return str;
     } 
     public static void main(String[] args) { 
      String str="1234"; 
     str=changestr(str); 
      System.out.println(str); 
   }
}楼主这样改一下就是welcome了

Answer 24

推荐你看一下这个博客：
http://blog.csdn.net/u012367513/article/details/24672373

Answer 25

简单点给你说吧
调用changestr(String str)方法后，String str="1234"; 这个str变量的引用地址指向了str="welcome"; 

Answer 26

这个主要问你的是传值还是传引用，八大数据类型 传的是值，它会新建一个新的str，然后指向新的值，不会影响以前的值，对象是传的引用，他只会新建一个新的引用，但是引用对应的内存地址还是不变的，所以如果你想让他不变的话，重新new下，实例化一个新的内存地址。

Answer 27

在调用方法的时候，栈内存中分配一个名为str的变量，并将str赋值为传递过来的实参，也就是"1234"，然后再将str赋值为"welcome"，这个str是在该方法中的str，不是main中的str，所以main中输出的当然是"1234"。
String不同于普通的类，String是不可变的，当给changeStr方法中的形参赋值时，是重新分配一块内存，str指向这里。所以与传入的参数str指向的不是同一块地址。

Answer 28

楼上的好像是说错了    你们真的知道什么是传值吗？如果传值会发生拷贝  下面的怎么解释。
import java.util.Scanner;public class java {    public static int i = 0;
    public static Scanner sc = new Scanner(System.in);
    public static byte[] buffer = new byte[1024*1024*50]; // 50兆的字符串 你猜他会递归多少次呢？
    public static String arg = new String(buffer);
 
    public static void digui(String arg) {
int j = ++i;
System.out.println("这个是第  N  次递归了"+j);
sc.next();
digui(arg);
System.out.println("这个是第  N  次递归完成了 "+j);
    }
 
    public static void main(String[] args) {
        digui(arg); 
    }
}

Answer 29

public class Test { 
 public static void changestr(String str){ 
     
       str="welcome"; 
      } 
      public static void main(String[] args) { 
       String str="1234"; 
       changestr(str); 
       System.out.println(str); 
    }
 } ----------------------------------------------------------
changestr(String str)村中有一个叫str的人，他的知名度是changestr村中；
main()村中也有一个叫str的人，他的知名度在main村中;
当我们在main()村中喊str时，习惯上都是指main()村中的str;
因此输出1234，

Answer 30

你这是值传递，基本数据类型、基本数据类型的封装类型、String的传递，都是值传递，有的人管值传递叫作值的拷贝，顾名思议，即是将该对像的堆内存中所对应的值，拷贝一份，将这个值传递给函数计算。这样下来，函数的计算结果，并不影响栈地址所指向的值，所改变的，只是这个拷贝出来的值。所以是不会变的，以下是我昨天写的博客。http://blog.csdn.net/javaloverkehui/article/details/37504989

Answer 31

什么鸟拷贝不拷贝的，这str又不是全局变量，change方法里改变了值，可是那方法又没返回值的。改了白改

Answer 32

说的对，楼上竟然有这么多人都说String是值传递。
其实这种理解是错误的，String是对象，当然是引用传递。这里的问题与是值传递还是引用传递没有关系。这里就算用的不是String，而是StringBuffer的话，在方法中重新赋值了，对原对象也不会有影响。
但是如果是调用StringBuffer的append方法则不一样了，只是String的设计有些特殊，并没有提供类似于StringBuffer的append方法。

Answer 33

首先，String是对象
其次，java只有值传递
当一个对象实例作为一个参数被传递到方法中时，参数的值就是该对象的引用一个副本。指向同一个对象,对象的内容可以在被调用的方法中改变，但对象的引用(不是引用的副本)是永远不会改变的。
但是int之类的基础类型参数的值就是本身的值最后为啥String的参数传递看上去像int之类的基础类型一样呢？
String类中的每一次看起来会修改String值的方法，实际上都是创建了一个新的String对象。
具体去看jdk里String实现的代码，顺便说下String 是final的

Answer 34

看看大家的回复，太欢乐了，都快笑出眼泪了看来让两个Java程序员讨论“传值”、“传址”、“传引用”，是最容易掐出一团毛线来的了

Answer 35

我的理解是 输出的是str  和change 方法有个毛毛关系，把str给了change 又没有对 str 本身产生任何关系   str都没有变动过，那么原来是什么就是什么     把str= “1234” 然后change又怎么样呢..........   就算change方法里面的   str=welcome   又怎么样呢，，，，main方法里面又没有说要把change的内容输出、、、、

Answer 36

这里用内存的分析方法你或许能更清楚，希望对你有所帮助
注：下面我解释中的str1是main方法中定义的，str2是changestr定义的，两个都属于局部变量，但是作用域不同
public class Test { 
public static void changestr(String str){ 
    
      str="welcome"; 
     } 
     //程序执行的入口main方法，从这里开始读程序
     public static void main(String[] args) { 
      String str="1234"; 
      //执行完上面的赋值语句后，系统会分配一块内存，里面存的值是1234，名字是str1
      changestr(str); 
      //此处执行，实参的值str1会传递给方法changestr的形参str2,系统会再分配一块内存，给str2，里面存的值也是1234，
      //当执行str="welcome"; 后，str2的值被修改成welcome,方法执行完毕系统将str2擦除，而str1的值没有被修改，还是1234，
      System.out.println(str); 
   }
}关于内存的分析你可以看一下马士兵的视频：尚学堂科技_马士兵_J2SE_5.0_第03章_面向对象\ 06_内存解析_1
                                                                                                                                                                         \ 07_内存解析_2 
                                                                                                                                                                         \ 08_内存解析_3 

Answer 37

java所有的参数传递都是地址传递，就没传值的。问题是，对于int double string之类的“简单”类型，它的每一次赋值不是说把原先地址的内容改掉，而是给你一个新的地址，这个地址包含修改之后的新内容。所以这样一来，LZ的方法里面“重新赋值”，其实并没有修改原先传进来的那个地址的内容，当然也就传不回去了。

Answer 38

本例中有两个str，changestr方法中一个，main方法中一个，占用的是不同的内存空间。当调用changestr时，采用的是值传递，str被改成“1234”，但这并不影响main方法中的str，程序继续向下运行，当changestr方法结束时，changestr中的str已经被清除了，再往下执行，到输出语句，str便是“1234”。
所以，在本例中，无论是从值传递的角度看，还是从作用域的角度看，结果都是“1234”。

Answer 39

返回值类型为void
public static String changestr(String str){ 
    
      str="welcome";
      return str;
     } 
     public static void main(String[] args) { 
      String str="1234"; 
     String str2 =  changestr(str); 
      System.out.println(str); 
   }
}改成这样就和你像的一样了

Answer 40

public static String changestr(String str) {
str = "welcome";
return str;
} public static void main(String[] args) {
String str = "1234";
str = changestr(str);
System.out.println(str);
}
呵呵！我得到welcom了

Answer 41

除了5楼说的之外，还有一个全局变量和局部变量的问题，局部变量在方法中定义，只能在方法中应用，所以change('str')这个语句相当于是不执行的！

Answer 42

String str1 = "1234";
String str2 = "1234"+"";
String str3 = str1+"";
System.out.println(str1==str2);
System.out.println(str1==str3);
System.out.println(str2==str3);