(转)java程序调用内存变化过程分析（详细）

 1 package oop;
 2  
 3 /**
 4  * 说明：实体类
 5  *
 6  * @author huayu
 7  * @date 2018/8/3 
 8  */
 9 public class Birthday {
10     private int day;
11     private int month;
12     private int year;
13     //有参构造方法
14     public Birthday(int day, int month, int year) {
15         this.day = day;
16         this.month = month;
17         this.year = year;
18     }
19  
20     public int getDay() {
21         return day;
22     }
23  
24     public void setDay(int day) {
25         this.day = day;
26     }
27  
28     public int getMonth() {
29         return month;
30     }
31  
32     public void setMonth(int month) {
33         this.month = month;
34     }
35  
36     public int getYear() {
37         return year;
38     }
39  
40     public void setYear(int year) {
41         this.year = year;
42     }
43  
44     @Override
45     public String toString() {
46         return "Birthday{" +
47                 "day=" + day +
48                 ", month=" + month +
49                 ", year=" + year +
50                 ‘}‘;
51     }
52 }
53  
54  
55  
56  
57  
58  
59  
60  
61 import oop.Birthday;
62  
63 /**
64  * 说明：测试类
65  *
66  * @author huayu
67  * @date 2018/8/3 
68  */
69 public class TestBirthday {
70     public static void main(String[] args) {
71           //new TestBirthday();相当于调用了TestBirthday类的无参构造方法（编译器默认加的）
72 1.        TestBirthday test=new TestBirthday();
73           //调到这句在栈内存分配一块名为date，值为9的内存
74 2.        int date=9;
75           //new Birthday(7,7,1970)；相当于调用了Birthday类中的有参构造方法
76 3.        Birthday d1=new Birthday(7,7,1970);
77 4.        Birthday d2=new Birthday(1,1,2000);
78 5.        test.change1(date);
79 6.        test.change2(d1);
80 7.        test.change3(d2);
81 8.        System.out.println("date="+date);
82 9.        d1.toString();
83 10.       d2.toString();
84  
85     }
86     public void change1(int i){
87 11.        i=1234;
88     }
89     public void change2(Birthday b){
90 12.        b=new Birthday(22,2,2004);
91     }
92     public void change3(Birthday b){
93 13.        b.setDay(22);
94     }
95 }
96  

 1 /**
 2  * 说明：静态变量内存分析举例
 3  * 
 4  * @author huayu
 5  * @date 2018/8/3 
 6  */
 7 public class Cat {
 8     //静态成员变量，就算不new对象它也会在data seg里面保存一份，它属于整个类
 9     //不属于某个对象。int静态变量可以用来计数。
10     //对静态值访问：1.任何一个对象都可以访问这个静态对象，访问的时候都是同一块内存
11     //2.即便是没有对象，也可以通过 类名. 来访问 如：System.out  out是个静态变量
12 1.    private static  int sid=0;
13     //非静态成员变量 new对象的时候在堆内存对象中保存，每new一个对象产生一块
14 2.    private  String name;
15     //非静态成员变量 new对象的时候在堆内存对象中保存，每new一个对象产生一块
16 3.    private int id;
17  
18     public Cat(String name) {
19 4.        this.name = name;
20 5.        id=sid++;
21     }
22  
23     public void info(){
24 6.        System.out.println("My name is "+name+" No."+id);
25     }
26  
27     public static void main(String[] args) {
28         //静态变量sid属于整个Cat类，不属于某个对象，可以用类名.来访问，所以这儿没有new任何对 
29         //象，直接用类名.（Cat.sid）来访问的。
30 7.        Cat.sid=100;
31         //字符串常量分配在data seg
32 8.        Cat mimi=new Cat("mimi");
33 9.        Cat pipi=new Cat("pipi");
34 10.       mimi.info();
35 11.       pipi.info();
36  
37     }
38 }
39 My name is mimi No.id=100 sid= 102
40 My name is pipi No.id=101 sid= 102

 1 /**
 2  * 说明：将上面代码静态变量改为非静态的再做内存分析
 3  *
 4  * @author huayu
 5  * @date 2018/8/3 下午6:32
 6  */
 7 public class Cat1 {
 8     private  int sid=0;
 9     private  String name;
10     private int id;
11  
12     public Cat1(String name) {
13         this.name = name;
14         id=sid++;
15     }
16  
17     public void info(){
18         System.out.println("My name is "+name+" No.id="+id+" sid= "+sid);
19     }
20  
21     public static void main(String[] args) {
22 //        Cat1.sid=100;
23         Cat1 mimi=new Cat1("mimi");
24         Cat1 pipi=new Cat1("pipi");
25         mimi.info();
26         pipi.info();
27  
28     }
29 }
30 输出结果：
31 My name is mimi No.id=0 sid= 1
32 My name is pipi No.id=0 sid= 1