java知识 之 对象及其内存管理

读书笔记:《疯狂java 程序员的基本修养》第二章——对象及其内存管理

java中的内存管理分为两个方面:

  • 内存分配:指创建java对象时JVM为该对象在堆空间中所分配的内存空间。

  • 内存回收:指java 对象失去引用,变成垃圾时,JVM的垃圾回收机制自动清理该对象,并回收该对象所占用的内存。

虽然JVM 内置了垃圾回收机制,但仍可能导致内存泄露、资源泄露等,所以我们不能肆无忌惮的创建对象。此外,垃圾回收机制是由一个后台线程完成,也是很消耗性能的。

1.实例变量和类变量

java程序中的变量,大体可以分为成员变量局部变量。其中局部变量可分为如下三类:

  • 形参:在方法名中定义的变量,有方法调用者负责为其赋值,随着方法的结束而消亡。
  • 方法内局部变量:在方法内定义的变量,必须在方法内对其进行初始化。它从初始化完成后开始生效,随着方法结束而消亡。
  • 代码块内局部变量:在代码块内定义的变量,必须在代码块内对其显示初始化。从初始化完成后生效,随着代码块的结束而消亡。

局部变量的作用时间很短暂,他们被存在栈内存中。
类体内定义的变量为成员变量。如果使用static修饰,则为静态变量或者类变量,否则成为非静态变量或者实例变量。

static:
他的作用是将实例成员编程类成员。只能修饰在类里定义的成员部分,包括变量、方法、内部内(枚举与接口)、初始化块。不能用于修饰外部类、局部变量、局部内部类。

使用static修饰的成员变量是类类型,属于类本身,没有修饰的属于实例变量,属于该类的实例。在同一个JVM中,每个类可以创建多个java对象。同一个JVM中每个类只对应一个Class对象,机类变量只占一块内存空间,但是实例变量,每次创建便会分配一块内存空间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
class Person
{
String name;
int age;
static int eyeNum;
public void info()
{
System.out.println("我的名字是:" + name
+ ", 我的年龄是:" + age);
}
}
public class FieldTest
{
public static void main(String[] args)
{
// 类变量属于该类本身,只要该类初始化完成,
// 程序即可使用类变量。
Person.eyeNum = 2; //①
// 通过Person类访问eyeNum类变量
System.out.println("Person的eyeNum属性:"
+ Person.eyeNum);
// 创建第一个Person对象
Person p = new Person();
p.name = "猪八戒";
p.age = 300;
// 通过p访问Person类的eyeNum类变量
System.out.println("通过p变量访问eyeNum类变量:"
+ p.eyeNum); //②
p.info();
// 创建第二个Person对象
Person p2 = new Person();
p2.name = "孙悟空";
p2.age = 500;
p2.info();
// 通过p2修改Person类的eyeNum类变量
p2.eyeNum = 3; //③
// 分别通过p、p2和Person访问Person类的eyeNum类变量
System.out.println("通过p变量访问eyeNum类变量:"
+ p.eyeNum);
System.out.println("通过p2变量访问eyeNum类变量:"
+ p2.eyeNum);
System.out.println("通过Person类访问eyeNum类变量:"
+ Person.eyeNum);
}
}

上述代码中的内存分配如下:

当Person类初始化完成,类变量也随之初始化完成,不管再创建多少个Person对象,系统都不再为 eyeNum 分配内存,但会为 name 和age 分配内存并初始化。当eyeNum值改变后,通过每个Person对象访问eyeNum的值都随之改变。

a.实例变量的初始化

对于实例变量,它属于java对象本身,每次程序创建java对象时都会为其分配内存空间,并初始化。
实例变量初始化地方:

  • 定义实例化变量时;
  • 非静态初始化块中;
  • 构造器中。

其中前两种比第三种更早执行,而前两种的执行顺序与他们在程序中的排列顺序相同。它们三种作用完全类似,经过编译后都会提取到构造器中执行,且位于所有语句之前,定义变量赋值和初始化块赋值的顺序与他们在源代码中一致。

可以使用 javap命令查看java编译器的机制:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
用法: javap <options> <classes>
其中, 可能的选项包括:
-help --help -? 输出此用法消息
-version 版本信息
-v -verbose 输出附加信息
-l 输出行号和本地变量表
-public 仅显示公共类和成员
-protected 显示受保护的/公共类和成员
-package 显示程序包/受保护的/公共类
和成员 (默认)
-p -private 显示所有类和成员
-c 对代码进行反汇编
-s 输出内部类型签名
-sysinfo 显示正在处理的类的
系统信息 (路径, 大小, 日期, MD5 散列)
-constants 显示最终常量
-classpath <path> 指定查找用户类文件的位置
-cp <path> 指定查找用户类文件的位置
-bootclasspath <path> 覆盖引导类文件的位置

b.类变量的初始化

类变量属于java 类本身,每次运行时才会初始化。
类变量的初始化地方:

  • 定义类变量时初始化;
  • 静态代码块中初始化

如下代码,表面上看输出的是:17.2,17.2;但是实际上输出的是:-2.8,17.2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Price
{
// 类成员是Price实例
final static Price INSTANCE = new Price(2.8);
// 在定义一个类变量。
static double initPrice = 20;
// 定义该Price的currentPrice实例变量
double currentPrice;
public Price(double discount)
{
// 根据静态变量计算实例变量
currentPrice = initPrice - discount;
}
}
public class PriceTest
{
public static void main(String[] args)
{
// 通过Price的INSTANCE访问currentPrice实例变量
System.out.println(Price.INSTANCE.currentPrice);//输出:-2.8
// 显式创建Price实例
Price p = new Price(2.8);
// 通过先是创建的Price实例访问currentPrice实例变量
System.out.println(p.currentPrice); //输出:17.2
}
}

第一次使用Price 时,程序对其进行初始化,可分为两个阶段:
(1)系统为类变量分配内存空间;
(2)按初始化代码顺序对变量进行初始化。

这里的运行结果为:-2.8,17.2
说明:初始化第一阶段,系统先为 INSTANCE,initPrice两个类变量分配内存空间,他们的默认值为null和0.0,接着第二阶段依次为他们赋值。对 INSTANCE 赋值时要调用 Price(2.8),创建Price实例,为currentPrice赋值,此时,还未对 initPrice 赋值,就是用他的默认值0,则 currentPrice 值为-2.8,接着程序再次将 initPrice 赋值为20,但对于 currentPrice 实例变量已经不起作用了。

以下为在ide中的debug结果截图:

2.父类构造器

java中,创建对象时,首先会依次调用每个父类的非静态初始化块、构造器(总是先从Object开始),然后再使用本类的非静态初始化块和构造器进行初始化。在调用父类时可以用super进行显示调用,也可以隐式调用

在子类调用父类构造器时,有以下几种场景:

  • 子类构造器第一行代码是用super()进行显示调用父类构造器,则根据super传入的参数调用相应的构造器;
  • 子类构造器第一行代码是用this()进行显示调用本类中重载的构造器,则根据传入this的参数调用相应的构造器;
  • 之类构造器中没有this和super,则在执行子类构造器前,隐式调用父类无参构造器。

注:super和this都是显示调用构造器,只能在构造器中使用,且必须在第一行,只能使用它们其中之一,最多只能调用一次。

一般情况下,子类对象可以访问父类的实例变量,但父类不能访问子类的,因为父类不知道它会被哪个子类继承,子类又会添加怎样的方法。但在极端的情况下,父类可以访问子类变量的情况,如下实例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package cn.imtianx.p02;

class Base {
private int i = 2;
public Base() {
this.display();//this:运行时是Driver类型,编译时是Base 类型,这里是Driver对象
}
public void display() {
System.out.println(i);
}
}

// 继承Base的Derived子类
class Derived extends Base {
private int i = 22;
public Derived() {
i = 222;
}
public void display() {
System.out.println(i);
}
}
public class Test {
public static void main(String[] args) {
// 创建Derived的构造器创建实例
new Derived();
}
}

上面的代码执行后,输出的并不是2、22或者222,而是0。在调用Derived 的构造器前会隐式调用Base的无参构造器,初始化 i= 2,此时如果输出this.i则为2,它访问的是Base 类中的实例变量,但是当调用this.display()时,表现的为Driver对象的行为,对于driver对象,它的变量i还未赋初始值,仅仅是为其开辟了内存空间,其值为0。

在java 中,构造器负责实例变量的初始化(即,赋初始值),在执行构造器前,该对象内存空间已经被分配了,他们在内存中存的事其类型所对应的默认值。

在上面的代码中,出现了变量的编译时类型与运行时类型不同。通过该变量访问他所引用的对象的实例变量时,该实例变量的值由申明该变量的类型决定的,当通过该变量调用它所引用的实例对象的实例方法时,该方法将由它实际所引用的对象来决定

当子类重写父类方法时,也会出现父类调用之类方法的情形,如下具体代码,通过上面的则很容易理解。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
class Animal
{
private String desc;
public Animal()
{
this.desc = getDesc();
}
public String getDesc()
{
return "Animal";
}
public String toString()
{
return desc;
}
}
public class Wolf extends Animal
{
private String name;
private double weight;
public Wolf(String name , double weight)
{
this.name = name;
this.weight = weight;
}
// 重写父类的getDesc()方法
@Override
public String getDesc()
{
return "Wolf[name=" + name + " , weight="
+ weight + "]"; //输出:Wolf[name=null , weight=0.0]
}
public static void main(String[] args)
{
System.out.println(new Wolf("灰太狼" , 32.3));
}
}

3.父子实例的内存控制

java中的继承,在处理成员变量和方法时是不同的。如果之类重写了父类的方法,则完全覆盖父类的方法,并将其其移到子类中,但如果是完全同名的实例变量,则不会覆盖,不会从父类中移到子类中。所以,对于一个引用类型的变量,如果访问他所引用对象的实例变量时,该实例变量的值取决于申明该变量的类型,而调用方法时,则取决于它实际引用对象的类型。

在继承中,内存中子类实例保存有父类的变量的实例。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Base {
int count = 2;
}
class Mid extends Base {
int count = 20;
}
public class Sub extends Mid {
int count = 200;
public static void main(String[] args) {
// 创建一个Sub对象
Sub s = new Sub();
// 将Sub对象向上转型后赋为Mid、Base类型的变量
Mid s2m = s;
Base s2b = s;
// 分别通过3个变量来访问count实例变量
System.out.println(s.count); //输出:200
System.out.println(s2m.count); //输出:20
System.out.println(s2b.count); //输出:2
}
}

内存中的示意图:

在内存中只有一个Sub对象,并没有Mid和Base对象,但存在3个count的实例变量。

子类中会隐藏父类的变量可以通过super来获取,对于类变量,也可以通过super来访问。

4.final 修饰符

final 的修饰范围:

  • 修饰变量,被赋初始值后不可重新赋值;
  • 修饰方法 ,不能被重写;
  • 修饰类,不能派生出子类。

对于final 类型的变量,初始化可以在:定义时、非静态代码块和构造器中;对于final 类型的类变量,初始化可以在:定义时和静态代码块中。

当final类型的变量定义时就指定初始值,那么该该变量本质上是一个“宏变量”,编译器会把用到该变量的地方直接用其值替换。

如果在内部内中使用局部变量,必须将其指定为final类型的。普通的变量作用域就是该方法,随着方法的执行结束,局部变量也随之消失,但内部类可能产生隐式的“闭包”,使局部变量脱离它所在的方法继续存在。内部内可能扩大局部变量的作用域,如果内部内中访问的局部变量没有适用final修饰,则可以随意修改它的值,这样将会引起混乱,所以编译器要求被内部访问的局部变量必须使用final 修饰。

当前网速较慢或者你使用的浏览器不支持博客特定功能,请尝试刷新或换用Chrome、Firefox等现代浏览器