public class Examble {
                String str=new String ("student");
                char[]ch={'a','b','c'};
                public static void main(String[] args) {
                Examble ex=new Examble();
                ex.change(ex.str,ex.ch);
                System.out.println(ex.str+"and");
                System.out.println(ex.ch);

        }
                public void change(String str,char ch[]){
                        str="test ok";
                        ch[0]='g';
                }
}
//输出结果是：
student and gbc
为什么结果不是?：
test  ok and gbc
//ps:我目前在自学面向对象（里面的知识搞得稀里糊涂的，很不清楚）
希望大牛级人物帮我把过程分析清楚（过程很重要） 谢谢啊

1. /*
   
2. 因为String类是一个常量
   
3. 当你将字符串定义好的时候。str就已经存在于常量池中了。
   
4. 
   
5. */
   
6. 
   
7. public class Examble {
   
8.                 String str=new String ("student");
   
9.                 char[]ch={'a','b','c'};
   
10.                 public static void main(String[] args) {
    
11.                 Examble ex=new Examble();
    
12.                 ex.change(ex.str,ex.ch);
    
13.                 System.out.println(ex.str+"and");
    
14.                 System.out.println(ex.ch);
    
15. 
    
16.         }
    
17.                 public void change(String str,char ch[]){
    
18.                         /*
    
19.                                                 你在这里改变这个str的值是成功的。如果你在这里面直接输出肯定可以输出。test ok
    
20.                                                 但是这并不是你根本性的把str的值改变了。只是暂时性的把str的引用指向了test ok而已。
    
21.                                                 当这个函数执行完毕后。这个函数就已经被释放了。而str的引用自然而然的就回到了student上
    
22.                                                 如果我的解释你看不懂。你可以去看看毕老师视频上讲解String类的部分。我相信你看了后会更清晰的
    
23.                                                 */
    
24.                                                 str="test ok";
    
25.                                                 System.out.println(str);
    
26.                         ch[0]='g';
    
27.                 }
    
28. }

复制代码

这个是现在的运行结果。希望的解答你给你带来帮助

楼主看看这样行不行：

1. public class Examble {
   
2.                 String str=new String ("student");
   
3.                 char[]ch={'a','b','c'};
   
4.                 public static void main(String[] args) {
   
5.                 Examble ex=new Examble();
   
6.                 ex.change(ex.str,ex.ch);
   
7.                 System.out.println(ex.str+"and");
   
8.                 System.out.println(ex.ch);
   
9. 
   
10.         }
    
11.                 public void change(String str,char ch[]){
    
12.                         str=new String("test ok");
    
13.                         ch[0]='g';
    
14.                 }
    
15. }

复制代码

1. class Examble
   
2.          {
   
3.                 String str=new String ("test  ok");
   
4.                 char[]ch={'a','b','c'};
   
5. 
   
6.                 public static void main(String[] args)
   
7.                         {
   
8.                 Examble ex=new Examble();
   
9.                 ex.change(ex.str,ex.ch);
   
10.                 System.out.println(ex.str+"and");
    
11.                 System.out.println(ex.ch);
    
12. 
    
13.         }
    
14.                 public void change(String str,char ch[])
    
15.                                 {
    
16.                         str="student";
    
17.                         ch[0]='g';
    
18.                 }
    
19. }

复制代码

这样试试，因为按照你那样的执行的话，在往里面传入new String ("student")就把test  ok 给覆盖掉了
，那样是执行不到的，把两个换个位置试试，不然的话在new String("test  ok");这样也是可以的
个人理解，上面是该好的，代码

补充一下，java中对象参数传递的是对象的引用，也就是change(String str ,char ch[])中str只是类中str的一个引用，当在change函数中给str赋值时，只是将change函数中的str指向了另一个字符串，但类中str指向的位置并没有变，画个图楼主更明白