相信大多数的java初学者都会有这种经历：碰到一段代码的时候，不知该从何下手分析，不知道这段代码到底是怎么运行最后得到结果的..... 等等吧，很多让人头疼的问题，作为一名合格的程序员呢，遇到问题一定要思路清晰，不要将错就错，蒙混过关，这一点很重要！
鉴于笔者最近恶补了java基础，在这儿给大家总结了一些java代码内存分析的经验，希望可以对家有所帮助。
在分析内存之前呢，通过这个图让大家明白计算机是怎么处理一个程序的。
简单总结一下：1.计算机首先从硬盘拿到程序，加载（load）到内存区
2.操作系统找到main方法开始执行
3.执行代码过程中的内存管理：
内存中分四块：分别是heap（堆）、stack（栈）、data segment
（数据区）、code segmen（代码区），各个区所存储的内容图中已
标注。
接下来，
给大家举几个例子程序，分别进行内存分析
**
程序一：
**
public class Person {
static int id;
static int age;
Person(int _id, int _age) {
id = _id;
age = _age;
}
public static void main(String[] args) {
Person tom = new Person(1,25);
System.out.println("id= " + id + " age= " + age);
}
}内存分析图：
第一步：从main方法入手，首先看到要实现一个Person类对象，该对象的名字是tom，则在stack中立马分配出一块空间用来存tom这个对象名，它指向heap中的Person对象（上文提到heap中存储new出来的东西）
注：图中局部变量tom的内容为xxx，xxx实际为Person对象在堆中的地址，在此处用xxx
代替。
第二步：调用Person中的构造方法，此时定义了两个局部变量（要存储到stack中）_id和_age，则立马在stack中分配两块空间用于存储这两个局部变量，接下来把1和25分别传给这两个变量
第三步：执行id=_id; age=_age;这两句，把_id和_age的值传给Person对象
第四步：局部变量_id和_age消失（java的垃圾回收机制）
到此完成Person对象的创建，执行输出语句，程序运行结束。
**
程序二：super引用，动态绑定及多态
**
说到多态，就先给大家巩固一下动态绑定和多态的概念吧：
动态绑定：在执行期间（非编译期间）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。
简单的来说，动态绑定就是根据实际new的对象所属的类调用方法，帮助程序的扩展性达到极致。
多态的话，要知道多态产生的三个条件：
1.有继承
2.有重写
3.父类引用指向子类对象
//abstract 关键字 ---> 抽象类，抽象类一定被继承，抽象方法一定被重写
class Animal { //可以这样声明 absrtact class Animal
private String name;
Animal(String name) {
this.name = name;
}
public void enjoy() {
System.out.println("叫声...");
}
}
class Cat extends Animal{
private String eyescolor;
Cat(String n,String c) {
super(n);
eyescolor = c;
}
public void enjoy() {
System.out.println("猫叫声....");
}
}
class Dog extends Animal {
private String furCorlor;
Dog(String n, String f) {
super(n);
furCorlor = f;
}
public void enjoy() {
System.out.println("狗叫声...");
}
}
class Lady {
private String name;
private Animal pet;
Lady(String name, Animal pet) {
this.name = name;
this.pet = pet;
}
public void petEnjoy() {
pet.enjoy();
}
}
public class TestAnimal {
public static void main(String[] args) {
Cat c = new Cat("catname","blue");
Dog d = new Dog("dogname","black");
c.enjoy();
d.enjoy();
Lady l1 = new Lady("l1",c);
Lady l2 = new Lady("l2",d);
l1.petEnjoy();
l2.petEnjoy();
}
}内存分析图：
老样子，从main方法入手：
第一步，Cat c = new Cat("catname","blue");
当你new一个子类对象出来的时候，其内部就已经包含父类对象，并且该子类对象的super引用会指向其父类对象。
此处分两小步给大家说明：（stack中局部变量的产生过程不再赘述，可参考程序一）
（1）new出来的Cat对象中包含Animal对象，Animal对象有一个成员变量name，自动初始化为null，C对象有一个成员变量eyescolor，自动初始化为null。
（2）传“catname”和“blue”这两个参数，“blue”直接赋值给eyescolor，而“catname”传进去后，通过super(n)方法，调用其父类对象的构造方法，使name值等于“catname”
第二步，Dog d = new Dog("dogname","black");
内存分析同第一步（此处省略）
第三步，c.enjoy(); d.enjoy();
此时，c指向的是Cat对象，但是Cat对象中包含其父类Animal对象，这两个对象都含有enjoy()方法，那么应该调用哪一个呢？这就涉及到了java的动态绑定机制了，你new出来的对象实际是Cat对象，那么就调用Cat对象的方法，而不是调用Animal对象的enjoy()方法；同理，d.enjoy()调用的是Dog对象的enjoy()方法。
所以，输出结果为
第四步，Lady l1 = new Lady("l1",c);
Lady l2 = new Lady("l2",d);内存分析图：
此处Animl的引用pet指向了其子类对象c，也就是上文提到的“父类引用指向子类对象”，并且，有继承、有重写，这就是多态。
每一个创建出来的对象都有this引用，指向他自身
第五步， l1.petEnjoy();
l2.petEnjoy();
调用Lady的petEnjoy()方法，输出对应信息，最终输出结果为
程序三：数组
3.1 一维数组
public class Test {
public static void main(String[] args) {
Date[] days = new Date[3];
for(int i=0;i<3;i++) {
days[i] = new Date(2020,4,i+1);
}
}
}
class Date {
int year,month,day;
Date(int y, int m, int d) {
year = y;
month = m;
day = d;
}
}内存分析图
days指向堆中的一个数组，该数组中存放的是每一个Date对象的地址，每一个地址指向一个Date对象。（详细赋值过程可参考程序一）
3.2 二维数组
二维数组实际上是一维数组的数组
public class Array {
public static void main(String[] args) {
int[][] a = new int[][] {
{1,2,3},
{4,5,6},
{7,8,9}
};
}
}内存分析图
栈空间中a指向一个一维数组，该数组每块区域存放的是int型数组的地址。
