这应该属于String的堆内存和栈内存的运行过程，一直不懂，而且总是混淆，有没有能分清的好方法。
第一个
public class Demo01{
        public static void main(String args[]){
                String str1 = "hello" ;                        // 实例化字符串对象
                System.out.println("fun()方法调用之前：" + str1) ;
                fun(str1) ;                                                // 调用fun()方法
                System.out.println("fun()方法调用之后：" + str1) ;
        }
        public static void fun(String str2){                // 此处的方法由主方法直接调用
                str2 = "world" ;                                       
        }
};

第二个：

class Demo{
        String temp = "hello" ;               
};
public class RefDemo02{
        public static void main(String args[]){
                Demo d1 = new Demo() ;        // 实例化Demo对象
                d1.temp = "world" ;               
                System.out.println("fun()方法调用之前：" + d1.temp) ;
                fun(d1) ;
                System.out.println("fun()方法调用之后：" + d1.temp) ;
        }
        public static void fun(Demo d2){               
                d2.temp = "hello world" ;                                                
        }
};

这两个代码是这么运行的，它们有什么区别？

两个基本都一样,
这里就说第一个吧.


这应该属于String的堆内存和栈内存的运行过程，一直不懂，而且总是混淆，有没有能分清的好方法。
第一个
public class Demo01{
        public static void main(String args[]){
                String str1 = "hello" ;                        // 实例化字符串对象  -- 这里不叫实例化, 只是在栈初始化一个属性,而且属于局部变量
                System.out.println("fun()方法调用之前：" + str1) ;
                fun(str1) ;                                                // 调用fun()方法  -- 是值传递,不是引用传递,而str1的值不变,作用域的问题
                System.out.println("fun()方法调用之后：" + str1) ;           -- 打印的还是局部变量中的str1值,也就是hello
        }
        public static void fun(String str2){                // 此处的方法由主方法直接调用
                str2 = "world" ;                                       
        }
};

1. class Demo{
   
2.         String temp = "hello" ;               
   
3. };
   
4. public class Demo2{
   
5.         public static void main(String args[]){
   
6.                 Demo d1 = new Demo() ;        // 实例化Demo对象
   
7.                 d1.temp = "world" ;           // 对Demo的temp的值进行覆盖，成为world   
   
8.                 System.out.println("fun()方法调用之前：" + d1.temp) ;//打印world
   
9.                 fun(d1) ;//调用下面的函数，传个Demo的对象并修改值为hello world;
   
10.                 System.out.println("fun()方法调用之后：" + d1.temp) ;//打印出hello world
    
11.         }
    
12.         public static void fun(Demo d2){               
    
13.                 d2.temp = "hello world" ;                                                
    
14.         }
    
15. };
    
16. 
    

复制代码

1. public class Demo1{
   
2.         public static void main(String args[]){
   
3.                 String str1 = "hello" ;                        // 实例化字符串对象
   
4.                 System.out.println("fun()方法调用之前：" + str1) ;
   
5.                 fun(str1) ;                                                // 调用fun()方法
   
6.                 System.out.println("fun()方法调用之后：" + fun(str1)) ;
   
7.         }
   
8.         public static String fun(String str2){                // 此处的方法由主方法直接调用
   
9.                 str2 = "world" ;
   
10.                 return str2;                                       
    
11.         }
    
12. };
    
13. 
    
14. 
    

复制代码

你写的第一个没意义，打印的都是str1，都帮你改了下，解释都有

区别就是: 一个传入的是字符串，进行覆盖
另一个就是传入一个对象，改变属性的值

我记得老师说过，String str =“XXXXXXX”，这种方式的字符串是常量，，，不太明白1L说的为什么会是局部变量