Day7---类的生命周期(1)

首先引用一段别人发的代码，觉得是很好的例子

class SingleTon {
	private static SingleTon singleTon = new SingleTon();
	public static int count1;
	public static int count2 = 0;
	private SingleTon() {
		count1++;
		count2++;
	}

	public static SingleTon getInstance() {
		return singleTon;
	}
}

public class Test {
	public static void main(String[] args) {
		SingleTon singleTon = SingleTon.getInstance();
		System.out.println("count1=" + singleTon.count1);
		System.out.println("count2=" + singleTon.count2);
	}
}

输出结果，最后再解释该结果。

count1=1
count2=0

1. java虚拟机及程序的生命周期

当通过java命令运行一个java程序时，就启动了一个java虚拟机进程。java虚拟机进程从启动到终止的过程，称为java虚拟机的生命周期。在以下情况，java虚拟机将结束生命周期：

• 程序正常执行结束
• 程序在执行中因为出现异常或错误而异常终止
• 执行了System.exit()方法
• 因为操作系统出现错误而导致java虚拟机进程终止

java虚拟机处于生命周期中时，它的任务就是运行java程序，java程序从运行到终止的过程称为程序的生命周期，和java虚拟机的生命周期是一致的。

2. 类的加载、连接和初始化

当java程序需要使用某个类时，java虚拟机会确保这个类已经被加载、连接和初始化。其中连接过程包括验证、准备和解析三个子步骤。这些过程必须严格按照顺序进行：

1. 加载：查找并加载类的二进制数据
2. 连接
   验证：确保被加载类的正确性；
   准备：为类的静态变量分配内存，并将其初始化为默认值；
   解析：把类中的符号引用转换为直接引用
3. 初始化：给类的符号引用转换为直接引用

2.1 类的加载

类的加载是指把类的.class文件中的二进制数据读入到内存中，把它存放在运行时数据区的方法区内，然后在堆区创建一个java.lang.Class对象，用来封装类在方法区内的数据结构。
java虚拟机能够从多种来源加载类的二进制数据，包括：

• 从本地文件系统中加载类的.class文件，这也是最常见的加载方式
• 通过网络下载类的.class文件
• 从ZIP、JAR或其他类型的归档文件中提取.class文件
• 从一个专有数据库中提取.class文件
• 从一个java源文件动态编译为.class文件

类加载的最终产品是位于运行时数据区的堆区的Class对象，Class对象里封装了类在方法区内的数据结构，并且向java程序提供了访问类在方法区内的数据结构的接口。
类的加载是由类加载器完成的，包括java虚拟机自带的加载器和用户自定义的类加载器。类加载器的内容下一次再写。

2.2 类的连接

2.2.1 类的验证

当类被加载后，就进入连接阶段。连接就是把已经读入内存的类的二进制数据合并到JRE中。连接的第一步是验证，保证被加载的类有正确的内部结构，并且与其他类协调一致。如果java虚拟机检查到错误，就会抛出相应的Error对象。
有一个问题，由java编译器生成的java类的二进制数据一定是正确的，为什么还要验证呢？因为java虚拟机不知道这个二进制数据到底是java编译器编译生成的，还是黑客弄的。类的验证可以确保程序被安全执行。
类的验证主要包括以下内容：

• 类文件的结构检查。确保类文件遵从java类文件的固定格式
• 语义检查。确保类本身符合java语言的语法规定
• 字节码验证。确保字节码流可以被java虚拟机安全地执行。字节码流代表java方法，它是由被称作操作码的单字节指令组成的序列，每一个操作码后都跟着一个或者多个操作数。字节码验证步骤会检查每个操作码是否合法，即是否有着合法的操作数
• 二进制兼容的验证。确保相互引用的类之间协调一致。例如，当Worker类中调用Car类中的run()方法，java虚拟机在验证Worker类的时候，会检查在方法区内是否存在Car类的run()方法，假如不存在，就会抛出MoSuchMethodError错误

2.2.2 类的准备

在准备阶段，java虚拟机为类的静态变量分配内存，并设置默认的初始值。例如，int类型，分配4个字节的内存空间，默认初始值0，Object类型默认初始值null。

2.2.3 类的解析

在解析阶段，java虚拟机会把类的二进制数据中的符号引用替换为直接引用。例如，在Worker类中定义的gotoWork()方法，其中引用Car类的run()方法。

public void gotoWork(){
	car.run();//这段代码在Worker类的二进制数据中表示为符号引用
}

在Worker类的二进制数据中，包含了对Car类的run()方法的符号引用，它由run()方法的全名和描述符组成，在解析阶段，java虚拟机会把这个符号引用替换为一个指针，该指针指向Car类的run()方法在方法区内的内存位置，这个指针就是直接引用。

2.2.4 类的初始化

java虚拟机在这一阶段执行初始化操作，为类的静态变量赋予初始值。静态变量的初始化可以是在声明静态变量时直接赋值，也可以是在静态代码块中执行赋值操作。

public static int i=0;//直接赋值
public static int j;//静态代码块中赋值
static{
	j=9;
}

java虚拟机初始化一个类包含以下步骤：

1. 如果这个类没有被加载和连接，那就先进行加载和连接
2. 如果类存在直接的父类，并且这个父类没有被初始化，就先初始化该类的父类
3. 如果类中存在初始化语句，就依次执行这些初始化语句

class Base{
	static int a=1;
	static{
		System.out.println("父类静态代码块");
	}
}
class Sub extends Base{
	static int b=9;
	static{
		System.out.println("子类静态代码块");
	}
}

public class Test332{
	static{
		System.out.println("主程序静态代码块");
	}
	public static void main(String[] args) {
		Base base;
		System.out.println("声明变量之后");
		base=new Base();
		System.out.println("创建Base类型对象实例后");
		System.out.println(base.a);
		System.out.println(Sub.a);
		System.out.println(Sub.b);
	}
}

输出结果

主程序静态代码块
声明变量之后
父类静态代码块
创建Base类型对象实例后
1
1
子类静态代码块
9

如果把main()方法中base=new Base();换成base=new Sub();，结果输出

主程序静态代码块
声明变量之后
父类静态代码块
子类静态代码块
创建Base类型对象实例后
1
1
9

2.3 类的初始化时机

java虚拟机只有在程序首次主动使用一个类或接口时才会初始化它。只有六种情况被看做是程序对类或接口的主动使用。

1. 创建类的实例。途径包括new关键字、反射、克隆、反序列化等
2. 调用类的静态方法
3. 访问类的静态变量或对类的静态变量赋值
4. 调用javaAPI的某些反射方法。比如Class.forName(“类名”)，返回这个类的Class实例对象。如果此时这个类还没初始化，forName(“类名”)方法就会触发对类的初始化
5. 初始化一个类的子类
6. 虚拟机启动时的启动类，即包含main()方法的那个类

下面介绍一些特殊情况：

1. 对于final类型的静态变量，如果在编译时就能确定变量的值，那么这种变量被称作编译时常量。在程序中使用编译时常量不会触发类的初始化。

   class Sub extends Base{                                                         //不会初始化
   	final static int a=1;
   	static{
   		System.out.println("子类静态代码块");
   	}
   }
   
   public class Test332{
   	public static void main(String[] args) {
   		System.out.println(Sub.a);
   	}
   }
   

   class Sub extends Base{                                                      //会初始化
   	final static int c=(int)Math.random()*10;                                //因为编译阶段无法确定c的值
   	static{
   		System.out.println("子类静态代码块");
   	}
   }
   public class Test332{
   	public static void main(String[] args) {
   		System.out.println(Sub.c);
   	}
   }
   

   class Sub extends Base{                                                       //会初始化
   	final static int a;
   	static{
   		a=8;
   	}
   	static{
   		System.out.println("子类静态代码块");
   	}
   }
   
   public class Test332{
   	public static void main(String[] args) {
   		System.out.println(Sub.a);
   	}
   }
   

2. 父类中定义的静态变量，通过子类类名访问时，不会对子类初始化，只会初始化父类。对于静态字段，只有直接定义这个字段的类才会被初始化

3. 通过数组定义来引用类，不会触发类的初始化

   class Sub extends Base{
   	static{
   		System.out.println("子类静态代码块");
   	}
   }
   
   public class Test332{
   	public static void main(String[] args) {
   		Sub sub[]=new Sub[3];                                                   //不会初始化Sub类
   	}
   }
   

4. 调用ClassLoader类的loadClass()方法加载一个类，不是对类的主动使用，不会导致类的初始化

3. 开篇的实例讲解

class SingleTon{
	private static SingleTon singleTon = new SingleTon();
	public static int count1;
	public static int count2 = 0;
	private SingleTon() {
		count1++;
		count2++;
	}

	public static SingleTon getInstance() {
		return singleTon;
	}
}

public class Test{
	public static void main(String[] args) {
		SingleTon singleTon = SingleTon.getInstance();
		System.out.println("count1=" + singleTon.count1);
		System.out.println("count2=" + singleTon.count2);
	}
}

1. java虚拟机首先找到main()入口，执行SingleTon.getInstance();，调用类的静态方法，触发类的初始化。
2. SingleTon类加载、连接，在连接中的准备过程中，为静态变量count1和count2分配内存并赋予默认初始值0，为singleTon分配内存并赋值null；
3. 在初始化过程中，为类的静态变量赋值和执行静态代码块。首先为singleTon赋值new SingleTon()，调用构造方法，此时count1=1，count2=1；
4. count1未赋值，count1=1不变。count2赋值为0，count2=0。所以最终输出count1=1，count2=0

下列代码输出结果就是count1=1，count2=1。你知道为什么了吧？我就不解释了。

class SingleTon {
	public static int count1;
	public static int count2 = 0;
	private static SingleTon singleTon = new SingleTon();
	private SingleTon() {
		count1++;
		count2++;
	}

	public static SingleTon getInstance() {
		return singleTon;
	}
}

public class Test332{
	public static void main(String[] args) {
		SingleTon singleTon = SingleTon.getInstance();
		System.out.println("count1=" + singleTon.count1);
		System.out.println("count2=" + singleTon.count2);
	}
}