一.java虚拟机运行时内存分配图
二.栈 堆 方法区简介
1.栈
1. 每个方法被调用都会创建一个栈帧(存储局部变量、操作数、方法出口等)
2. JVM为每个线程创建一个栈，用于存放该线程执行方法的信息(实际参数、局部变量等)
3. 栈属于线程私有，不能实现线程间的共享!
4. 栈的存储特性是“先进后出，后进先出”
5. 栈是由系统自动分配，速度快!栈是一个连续的内存空间!
2. 堆
1. 堆用于存储创建好的对象和数组(数组也是对象)
2. JVM只有一个堆，被所有线程共享
3. 堆是一个不连续的内存空间，分配灵活，速度慢!
3.方法区
1. JVM只有一个方法区，被所有线程共享!
3. 用来存放程序中永远是不变或唯一的内容。(类信息【Class对象】、静态变量、字符串常量等)
三.实例讲解
1.代码
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;
}
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; }
Circle increaseRadius() {
radius++;
return this;
}
}
public class TestCircle {
public static void main(String args[]) {
Circle c1 = new Circle(new Point(1.0, 2.0), 2.0);
System.out.println("c1:" + c1.getO().getX());
c1.setO(5, 6);
System.out.println(c1.increaseRadius().increaseRadius().area());
}
}
2. 构造函数 Circle c1 = new Circle(new Point(1.0,2.0), 2.0);
2.1 Circle c1
首先在栈内创建一个c1引用,指向地址不详
2.2 new Point(1.0,2.0)
在堆内创建一个Point对象 ,开始时Point内的变量X Y皆为0,
在栈内创建x1,y1,然后将其赋值给Point的x y,构造完成时内存分配如图
构造函数运行完成后,栈内x1,y1空间立刻释放
2.3 在堆内创建Circle对象 new Circle(new Point(1.0,2.0), 2.0)
同样，Circle对象刚创建时引用类型值为null,基础变量值为0,然后进入构造函数,在栈内创建一个指向刚才创建的Point对象的P和值为2.0的r,
然后用这两个元素初始化Circle内元素,使o指向Point,radius值变为2.0
构造函数完成后,栈内的r和p立刻释放
最后将c1指向Circle对象 Circle c1 = new Circle(new Point(1.0,2.0), 2.0);
3. c1.getO().getX()
首先调用geto获得c1所指向的Point,在栈中创建一个引用指向O引用
然后调用getX(),返回其X值,在栈内创建一临时对象用于存储X值
打印完成后,临时对象会被清理
4. c1.setO(5,6);
经过前面的学习,相信这个就很简单了,
在内存中创建临时变量x=5.0,y=6.0,然后通过赋值,改变c1内Point对象的值,SetO()结束后临时变量被清理.
5. c1.increaseRadius().increaseRadius().area() 关于this
首先c1调用increaseRadius()方法,返回一个Circle类的临时引用存储在栈内,指向c1对象,使radius变量+1.然后在通过这个临时引用再次调用increaseRadius()方法,使radius+1,再返回一个临时引用压栈,最后通过这个临时变量调用area()方法获取c1的增大半径后的面积.语句完成后两个栈内临时变量立刻被清理
四.static变量的内存分配
1.代码
class Cat {
public static int num = 0;
String name;
Cat(String name) {
this.name = name;
++num;
}
}
public class Main {
public static void main(String[] args) {
Cat c1 = new Cat("mimi");
Cat c2 = new Cat("miao");
System.out.println(Cat.num);
}
}
2.所有的字符串和static类型的静态成员变量都会预先加载于方法区内
所以上述代码执行时,内存分布如图,可以认为堆内c1,c2各有一引用指向方法区内对应元素
多态(动态绑定的内存分配)
1.代码
class Animal {
public String name;
Animal(String name) { this.name = name; }
void enjoy() { System.out.println("叫声"); }
}
class Dog extends Animal {
public String furName; //毛皮颜色
Dog(String name,String furName) { super(name); this.furName=furName;}
@Override
void enjoy() { System.out.println("汪汪汪"); }
}
class Cat extends Animal {
Cat(String name) { super(name); }
@Override
void enjoy() { System.out.println("miao"); }
}
class lady {
public String name;
public Animal pet;
lady(String name, Animal pet) {
this.name = name;
this.pet = pet;
}
void enjoy() { this.pet.enjoy(); }
void replace_pet(Animal pet) { this.pet = pet; }
}
public class Main {
public static void main(String[] args) {
Dog dog = new Dog("小黄","yellow");
lady w1 = new lady("张不悔", dog);
w1.pet.enjoy();
Cat cat = new Cat("大白","white");
lady w2=new lady("刘静",cat);
w2.pet.enjoy();
}
}
2.运行时,内存分布大致如图
在实际运行时,Lady内部的pet虽然是animal类型的引用,但是其指向的堆内存空间对象是一个完整的Dog对象,注意类内方法并不在堆内存储,类内方法存储在方法区内,堆中类对象只存储指向此方法的一个指针,因而打印出的enjoy结果是"汪汪",而不是"叫声".
但是因为pet类型是Animal,所以通过pet引用只能访问Animal类拥有的方法和变量,比如w1.pet.furname是错误的.因为pet引用并不知道他所引用的对象究竟是dog还是cat,只能判断出其至少是个Animal对象.
注
需要注意的是,栈内元素在使用完成后会立刻被清理,但是堆内创建的对象并不会立刻消失,而是在垃圾回收器启动回收后才会消失,而为了性能考虑,在内存充沛时,垃圾回收器并不会经常运行.所以可能某个元素已经空置了很久但是仍未被回收.
class Point {
int x, y;
Point(int _x, int _y) {
x = _x;
y = _y;
} //_x,_y在构造函数运行完成后会立刻消失
}
public class Main {
public static void main(String[] args) {
Point p1 = new Point(1, 2);
Point p2 = new Point(2, 3);
p1 = p2; //p1之前所指向的Point对象已经成为空置垃圾,但是不会被立刻回收
}
}