求解，为什么结果是hellojava？？？？

public class StringTest2 {

        public static void main(String[] args) {

                String s1="hello";
                String s2="java";
               
                test(s1,s2);
               
                System.out.println(s1+s2);
        }

        private static void test(String s1, String s2) {
                s2.replace('a', 'o');
                s1=s2;
        }

}

应为你定义了   s1=s2;  所以他们输出的值时一样的 。

1. public class StringTest2 {
   
2.         public static void main(String[] args) {
   
3.                 String s1="hello";
   
4.                 String s2="java";
   
5.                  
   
6.         test(s1,s2);
   
7.         //只是把s1和s2的值传递给test方法，该方法对这两个值进行操作，并未改变主函数中s1和s2  
   
8.         System.out.println(s1+s2);
   
9.     }
   
10.         private static void test(String s1, String s2) {
    
11.         s2.replace('a', 'o');
    
12.         s1=s2;
    
13.     }
    
14. }

复制代码

这是因为函数传递的实际上是地址值，原来的s1，s2不会被修改。关于这点我又一次在swap2个字符串的时候也发现了，但是我暂时还不知道应该如何才能把能改变原字符串的函数封装起来。

public class StringTest2 {

        public static void main(String[] args) {

                String s1="hello"; //常量数据区，不可修改
                String s2="java"; //常量数据区 ，不可修改
               
                test(s1,s2); //把两个引用传入，完全不能修改"hello", "java"
               
                System.out.println(s1+s2);
        }

        private static void test(String s1, String s2) {  //这个函数根本无法修改main() 中的s1,s2
                s2.replace('a', 'o');   //会在堆上创建一个新的对象。
                s1=s2;  
        }

}
要实现你的功能，可以这样：

1. class StringTest2 {
   
2. 
   
3.         public static void main(String[] args) {
   
4. 
   
5.                 String s1="hello";
   
6.                 String s2="java";
   
7. 
   
8.                 s1 = test(s1,s2);  //把修改后的新内存引用给s1
   
9. 
   
10.                 System.out.println(s1+s2); //这里把修改后堆上的s1和常量区的"java"组合
    
11.         }
    
12. 
    
13.         private static String test(String s1, String s2) {
    
14.                 return s2.replace('a', 'o');
    
15.         }
    
16. 
    
17. }

复制代码

test中的s1，s2是形式参数，main函数只是把s1和s2中的值拷贝了一份给形参s1，s2，所以test中的s1和s2无论怎么变化，都于事无补，根本影响不到main中的s1，s2，只能用返回值的方法获取，而且java中字符串是常量，所以s2调用replace方法会返回一个新的字符串，而不是在原有字符串上修改，你没有接收这个新的字符串，JVM考虑到字符串常量操作会引起很多中间值，所以才有了StringBuffer，建议你用StringBuffer，保证万无一失

字符串一旦创建是不会被改变的啊，只能改变变量的指向，字符串的replace()方法返回的是一个新的字符串，原来的字符串s2并没有变化，字符串变量在作为形参时，遵循值传递的原则，只是把字符串的值传入了test()方法中，而不是把s1="hello";s2="java";的引用传入，想要多个方法操作同一个字符串的变量，要把变量定义在方法外

楼主认为String是引用类型，但它有数据类型的特质，楼主这样做是想利用引用来传值，这样是行不通的，
private static void test(String s1, String s2) {
                s2.replace('a', 'o');
                s1=s2;
        }

想传入两个String来改变这String的值，其实确实在里面进行的操作，只是没有传出来罢了，java里没有想C/C++里的&（地址符号）或者C#里的ref(引用关键字),所以还是建议楼主老老实实的来个返回值：
建议楼主这么写：
public static void main(String[] args) throws IOException
                {        //主函数方法都是对的
                        String s1=new String("hello");
                String s2=new String("java");
               
               
               
                System.out.println(test(s1,s2));
        }

        private static String test(String s1, String s2) {
               
               
                s1+=s2.replace('a', 'o');
                return s1;
        }

记得老毕有个视频讲到了这个，但是找不到是哪个视频讲到的

老毕的哪个视频讲到这个问题了啊？？？

付东老师的视频有讲到哦  是在那次公开课讲的