Java的运行时数据存储机制

一直对Java运行时的数据存储机制不太懂，今天实践总结一下：

在JAVA中，有六个不同的地方可以存储数据：

1. 寄存器（register）。 这是最快的存储区，因为它位于不同于其他存储区的地方——处理器内部。但是寄存器的数量极其有限，所以寄存器由编译器根据需求进行分配。你不能直接控制，也不能在程序中感觉到寄存器存在的任何迹象。

    ------最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.

 

2. 栈（stack）。位于通用RAM中，但通过它的“栈指针”可以从处理器哪里获得支持。栈指针若向下移动，则分配新的内存；若向上移动，则释放那些 内存。这是一种快速有效的分配存储方法，仅次于寄存器。创建程序时候，JAVA编译器必须知道存储在栈内所有数据的确切大小和生命周期，因为它必须生成 相应的代码，以便上下移动栈指针。这一约束限制了程序的灵活性，所以虽然某些JAVA数据存储在栈中——特别是对象引用，但是JAVA对象不存储其 中。

    ------存放基本类型的变量数据和对象、数组的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中）

      一般来说，基本数据类型直接在栈中分配空间，局部变量（在方法代码段中定义的变量）也在栈中直接分配空间，当局部变量所在方法执行完成之后该空间便立刻被JVM回收，还有一种是引用数据类型，即我们通常所说的需要用关键字new创建出来的对象所对应的引用也是在栈空间中，此时，JVM在栈空间中给对象引用分配了一个地址空间（相当于一个门牌号，通过这个门牌号就可以找到你家），在堆空间中给该引用的对象分配一个空间，栈空间中的地址引用指向了堆空间中的对象区（通过门牌号找住址）；

 

3. 堆（heap）。一种通用性的内存池（也存在于RAM中），用于存放所以的JAVA对象。堆不同于栈的好处是：编译器不需要知道要从堆里分配多少存储区 域，也不必知道存储的数据在堆里存活多长时间。因此，在堆里分配存储有很大的灵活性。当你需要创建一个对象的时候，只需要new写一行简单的代码，当执行 这行代码时，会自动在堆里进行存储分配。当然，为这种灵活性必须要付出相应的代码。用堆进行存储分配比用栈进行存储存储需要更多的时间。

  ------存放所有new出来的对象。

 

4. 静态存储（static storage）。这里的“静态”是指“在固定的位置”。静态存储里存放程序运行时一直存在的数据。你可用关键字static来标识一个对象的特定元素是静态的，但JAVA对象本身从来不会存放在静态存储空间里。

  ------存放静态成员（static定义的）

 

5. 常量存储（constant storage）。常量值通常直接存放在程序代码内部，这样做是安全的，因为它们永远不会被改变。有时，在嵌入式系统中，常量本身会和其他部分分割离开，所以在这种情况下，可以选择将其放在ROM中

  ------存放字符串常量和基本类型常量（public static final） 

 

6. 非RAM存储。如果数据完全存活于程序之外，那么它可以不受程序的任何控制，在程序没有运行时也可以存在。

  ------硬盘等永久存储空间 

举例一：

定义一个Person类

public class Person {
	int id;
	int age;
	//Person类的构造函数：是定义在Java类中的一个用来初始化对象的函数
	public Person(int _id,int _age) {
		id = _id;
		age = _age;
	}

	public static void main(String[] args) {
		Person Tom = new Person(1, 25);
		Person John = new Person(2, 28);
	}
}

分析在内存里的运行过程：

详细过程：

        Person Tom是一个局部变量，所以在栈的内存空间里面会分配一块区域，是引用类型，里面装的是什么，我们先不管，但是可以明确的是，可以通过里面的内容找到相应的堆内存。new 一个Person，会调用它的构造方法。当调用构造方法时，方法里生成的变量是局部变量，所以在我们调用这个方法过程中，_id和_age也会在栈内存中有空间。

举例：Person Tom = new Person(1, 25);在调用构造方法时，会向里面传值，即_id的值为1，_age的值为25。new一个Person，在堆内存中new了一个实例对象，实例对象Person里有两个成员变量id和age。当调用构造方法时，会将_id和_age的值传给了id和age。方法调用完成之后，栈里面为它分配的空间全部消失。然后通过Tom里面的内容，找到这个对象。

 

任何一个局部变量都会分配在栈内存里面，只不过构造方法的局部变量一旦执行完成后就没了

注意：当没有指定构造函数时，编译器为类自动添加形如 类名（）{   }的无参构造函数， 所以当我们没有指定构造函数时，我们可以这样写：Point p = new Point();当我们已经定义了类似于Person类的有参构造方法了，那么编译器就不会默认给我们添加无参构造方法，这时，我们再写Person Jerry = new Person();就不行。

注意：构造方法没有返回值，即使是void也不行。

举例二：

这里转载于：点击打开链接

package demo;

public class Student {
    private String name;
    private int age;

    public void study() {
        System.out.println("I love study!");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

package demo;

public class StudentDemo {
    public static void main(String[] args) {
        Student student = new Student();

        System.out.println(student.getName() + ":" + student.getAge());
        student.setName("John");
        student.setAge(23);
        System.out.println(student.getName() + ":" + student.getAge());
        
        student.study();
        
        Student student2 = student;
        student2.setName("Jack");
        student2.setAge(25);
        System.out.println(student2.getName() + ":" + student2.getAge());
        System.out.println(student.getName() + ":" + student.getAge());
    }
}

当我们运行程序时，JVM会把Student类与StudentDemo类编译完然后加载到JVM中一个叫方法区的地方，类的成员变量与成员方法也被加载到方法区中，此时内存模型如下

可以看到study方法右边各有一个16进制的标记，而name与age变量没有，这是因为每个对象都有各自的成员变量，而类中的成员方法却可以被每个对象所共用，为了节省内存空间，JVM为方法分配了该标记（也叫内存地址）便于每个new出来的对象查找调用，接着JVM会自动寻找main方法，在栈中为main方法申请一个空间，这个过程也叫入栈，然后执行我们Student类中第5行代码

这时候，JVM在堆空间中分配一块内存给Student对象，并为其分配一个内存地址（如果对象的成员变量没有赋值，则JVM会为变量赋初始值），在栈中分配一块内存空间用于指向堆空间中的Student对象区的内存地址，此时内存模型如下：（更详细的过程看举例一）

接着看代码第8行与第9行

程序为student对象的成员变量赋值，JVM会根据student所指向的地址在堆内存中寻找Student类的变量，并为变量赋新的值

第12行

这时student对象调用study方法，JVM在栈空间中为study方法申请了一块内存空间

study方法执行完后，立即释放栈空间，代码第14行，

student2对象的引用指向了student所指向的地址

代码15与16行

为student2的变量赋值，由于student2与student指向了同一个地方，所以这时student对象中变量的值也被改变

到这，main方法中所有代码执行完毕，main方法所占用的栈空间也被回收，而堆空间等待GC回收

代码执行结果如下：

null:0
John:23
I love study!
Jack:25
Jack:25

举例三：

定义一个BirthDate类

public class BirthDate {
	private int day;
	private int month;
	private int year;
	
	public BirthDate(int d, int m, int y) {
		day = d;
		month = m;
		year = y;
	}

	public int getDay() {
		return day;
	}

	public void setDay(int d) {
		day = d;
	}

	public int getMonth() {
		return month;
	}

	public void setMonth(int m) {
		month = m;
	}

	public int getYear() {
		return year;
	}

	public void setYear(int y) {
		year = y;
	}
	public void display() {
		System.out.println(day + "-" + month + "-" + year);
	}
}

定义一个Test类

public class Test {

	public void change1(int i){
		i = 1234;
	}
	
	public void change2(BirthDate b){
		b = new BirthDate(22, 3, 2018);
	}
	
	public void change3(BirthDate b) {
		b.setDay(12);
	}
	public static void main(String[] args) {
		Test test = new Test();
		int date = 9;
		BirthDate d1 = new BirthDate(7, 7, 2017);
		BirthDate d2 = new BirthDate(2, 1, 2018);
		test.change1(date);
		test.change2(d1);
		test.change3(d2);
		System.out.println("date=" + date);
		d1.display();
		d2.display();
	}
}

我们根据main（）的代码一行一行的分析：

1.第1行：

这里是调用了Test的构造函数，我们并没有为其添加，这个是编译器自动添加的无参构造函数

2.第2行：

栈内存里多了一个变量date，里面装的是9。（基本类型就一块内存；引用类型两块内存）

3.第3-4行

先看d1:引用类型的变量有两块，先在栈内存中分配一块区域为d1,通过d1可以指向在堆中的内容。new一个BirthDay调用的是public BirthDate(int d, int m, int y) {}方法，这里面有三个形参，形参与局部变量同等对待，也分配在栈内存中。

     栈内存的y,m,d将值传给堆内存中的day,month,year，方法调用完毕之后，为这个方法分配的所有局部变量全部消失，所以y,m,d消失。

d2同理

4.第5行：

看一下：

有一个局部变量i，所以在栈内存中有一块区域为i,i的值传的是date的值：9，开始执行这个方法，i=1234，所以此时i的值又变成了1234。当方法执行结束后，i的内存空间消失。

  ——>——>

最后第5行方法调用完毕后，内存里面没有变化，但是实际上是有上述的变化的。

5.第6行:

看一下：

图1：将d1的值传过去，通过d1，可以找到堆内存中的对象。在栈内存里分配局部变量b，将d1的值传给b,也就是说通过b的值也可以找到d1的对象；

图2：执行change2里面的方法，new了一个对象（堆内存中），当然在这个过程中又调用了构造方法，在栈内存中分配了三个局部变量，传值后三个局部变量消失。b的指向换了，看图2

图3：b的指向变了之后，方法调用完毕，b这个局部变量消失。所以指向这个对象的引用也消失。看图3

图4：至于这个对象消失的时间，就看GC工作的时间

6.第7行：

看一下：

图1：将b指向d2引用的对象

图2：执行方法change3（）里面的内容，b.setDay这里有个局部变量d，将d的值传给b所指向的对象，同时也是d2指向的对象。

图3：将d的值传给b指向对象的day，方法执行完毕之后，局部变量d消失。同时change3的方法执行完毕后，b也就消失了，指向它的引用也消失了

7.第8-10行：

看一下：

再看一眼当时的内存：

程序运行结果：

date=9
7-7-2017
12-1-2018

举例四：

class Point {
    private double x;
    private double y;
    Point(double x1, double y1) { 
    	x = x1; 
    	y = y1;
    }
    public double getX() { return x; }
    public double getY() { return y; }
    public void setX(double i) { x = i; }
    public void setY(double i) { y = i; }
}

class Circle {
    private Point o;
    private double radius;
    Circle(Point p, double r) {
    	o = p; 
    	radius = r;
    }
    Circle(double r) {
        o = new Point(0.0, 0.0);
        radius = r;
    }
    
    boolean contains(Point p) {
    	double x = p.getX() - o.getX();
    	double y = p.getY() - o.getY();
    	if(x*x + y*y > radius * radius) return false;
    	else return true;
    }
    
    
    public void setO(double x, double y) {
        o.setX(x); 
        o.setY(y);
    }
    public Point getO() { return o; }
    public double getRadius() { return radius;}
    public void setRadius(double r) { radius = r;}
    public double area() { 
        return 3.14 * radius * radius;
    }
}

public class TestCircle {

	public static void main(String args[]) {
        Circle c1 = new Circle(new Point(1.0,2.0), 2.0);
        Circle c2 = new Circle(5.0);
        System.out.println("c1:("+c1.getO().getX()+","+c1.getO().getY()+"),"+c1.getRadius());
        System.out.println("c2:("+c2.getO().getX()+","+c2.getO().getY()+"),"+c2.getRadius());
        System.out.println("c1 area = "+c1.area());
        System.out.println("c1 area = "+c2.area());
        c1.setO(5,6);
        c2.setRadius(9.0);
        System.out.println("c1:("+c1.getO().getX()+","+c1.getO().getY()+"),"+c1.getRadius());
        System.out.println("c2:("+c2.getO().getX()+","+c2.getO().getY()+"),"+c2.getRadius());
        System.out.println("c1 area = "+c1.area());
        System.out.println("c1 area = "+c2.area());
        
        Point p1 = new Point(5.2, 6.3);
        System.out.println(c1.contains(p1));
        System.out.println(c1.contains(new Point(10.0,9.0)));
        
    }
}

第1行：（中间省略了一些过程）

第2行：（中间省略了一些过程）

第3行：

（1）c1.getO()这里分配一个临时的区域指向c1中o指向的内容

（2）c1.getO().getX()

c1.getO().getY()和c1.getRadius()同理。当打印出来之后，栈内存里面的临时内存都消失，回到原样。

第4行：同理

第5、6行：简单不赘述

第7行：

看一下： 

上图是setX之后。setY同理，当这个方法结束后，i，x,y在栈内存后都消失。

下面的代码不一一赘述。

结果：

c1:(1.0,2.0),2.0
c2:(0.0,0.0),5.0
c1 area = 12.56
c1 area = 78.5
c1:(5.0,6.0),2.0
c2:(0.0,0.0),9.0
c1 area = 12.56
c1 area = 254.34
true
false

举例五：static

public class Cat {
    private static int sid = 0;
    private String name; 
    int id;
    Cat(String name) {
        this.name = name;  
        id = sid++;
    }
    public void info(){
        System.out.println
               ("My name is "+name+" No."+id);
    }
    public static void main(String arg[]){

        Cat.sid = 100;
        Cat mimi = new Cat("mimi");
        Cat pipi = new Cat("pipi");
        mimi.info(); 
        pipi.info();
        System.out.println(Cat.sid);
    }
}

结果：

My name is mimi No.100
My name is pipi No.101
102

思考一下：

代码若是这样，打印结果会有什么不同呢？

 public static void main(String arg[]){

        Cat.sid = 100;
        Cat mimi = new Cat("mimi");
        mimi.sid = 2000;
        Cat pipi = new Cat("pipi");
        mimi.info(); 
        pipi.info();
        System.out.println(Cat.sid);
    }

结果：

My name is mimi No.100
My name is pipi No.2000
2001

举例六：super

class FatherClass {
    public int value;
    public void f(){
        value = 100;
        System.out.println
        ("FatherClass.value="+value);
    }
}

class ChildClass extends FatherClass {
    public int value;
    public void f() {
        super.f();
        value = 200;
        System.out.println
             ("ChildClass.value="+value);
        System.out.println(value);
        System.out.println(super.value);
    }
}

public class TestInherit {
	public static void main(String[] args) {
		ChildClass cc = new ChildClass();
		cc.f();
	}

}

第一行：ChildClass cc = new ChildClass();

第二行：cc.f();

执行完毕后

这里省略了一些过程，根据前面的几个例子，应该都能写的出来~~

FatherClass.value=100
ChildClass.value=200
200
100