java类的生命周期就是指一个class文件（java源文件编译后的文件）从加载到卸载的全过程。
目录
1.加载
我们编写一个java的源文件，经过编译后生成一个后缀名为.class的文件，这结合四字节码文件，java虚拟机就识别这种文件，java的生命周期就是class文件从加载到消亡的过程。
关于加载，其实，就是将源文件的class文件找到类的信息将其加载到方法区中，然后在堆区中实例化一个java.lang.Class对象，作为方法区中这个类的信息的入口。
但是这一功能是在JVM之外实现的，主要的原因是方便让应用程序自己决定如何获取这个类，在不同的虚拟机实现的方式不一定相同，hotspot虚拟机是采用需要时在加载的方式，也有其他是先预先加载的。（查找并加载类的二进制数据 ）
类加载器：
1、Java虚拟机自带的加载器
a. 根类加载器(使用C++编写，程序员无法在Java代码中获得该类)
b. 扩展加载器，使用Java代码实现
c. 系统加载器(应用加载器)，使用Java代码实现
2、用户自定义的类加载器
java.lang.ClassLoader的子类
用户可以定制类的加载方式
类加载器并不需要等到某个类被“首次主动使用”时再加载它。但调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。
2.连接
一般会跟加载阶段和初始化阶段交叉进行，过程由三部分组成：验证、准备和解析三步
（1）验证：
确定该类是否符合java语言的规范，有没有属性和行为的重复，继承是否合理，总之，就是保证jvm能够执行（确保被加载的类的正确性 ）
（2）准备：
主要做的就是为由static修饰的成员变量分配内存，并设置默认的初始值（为类的静态变量分配内存，并将其初始化为默认值）
默认初始值如下：
1.八种基本数据类型默认的初始值是0
2.引用类型默认的初始值是null
3.有static final修饰的会直接赋值，例如：static final int x=10；则默认就是10.
（3）解析：
这一阶段的任务就是把常量池中的符号引用转换为直接引用，说白了就是jvm会将所有的类或接口名、字段名、方法名转换为具体的内存地址。(把类中的符号引用转换为直接引用 )，有了直接引用那么引用的目标已经被载入内存。
3.初始化
(为类的静态变量赋予正确的初始值 )，并且只执行一次
静态变量的声明和静态代码块的初始化都可以看做静态变量的初始化，类的静态变量和静态代码块的初始化是有顺序的。顺序为类文件从上到下进行初始化，如果父类还没有初始化，那就先初始化父类。
这个阶段就是将静态变量（类变量）赋值的过程和静态代码块的初始化过程，即只有static修饰的才能被初始化，执行的顺序就是：
父类静态域或者静态代码块，然后是子类静态域或者子类静态代码块
4.使用
在类的使用过程中依然存在三步：对象实例化、垃圾收集、对象终结
（1）对象实例化：
就是执行类中构造函数的内容，如果该类存在父类JVM，会通过显示或者隐示的方式先执行父类的构造函数，在堆内存中为父类的实例变量开辟空间，并赋予默认的初始值，然后在根据构造函数的代码内容将真正的值赋予实例变量本身，再为本类的实例变量开辟空间，并赋予默认值，再使用构造函数赋值。然后，引用变量获取对象的首地址，通过操作对象来调用实例变量和方法
（2）垃圾收集：
当对象不再被引用的时候，就会被虚拟机标上特别的垃圾记号（Java1.2之前，通过引用计数器来标记是否需要垃圾回收；1.2之后都使用根搜索算法来判断是否垃圾回收），在堆中等待GC回收
（3）对象的终结：
对象被GC回收后，对象就不再存在，对象的生命也就走到了尽头
5.类卸载
即类的生命周期走到了最后一步，程序中不再有该类的引用，该类也就会被JVM执行垃圾回收，从此生命结束…
类卸载需要同时满足以下三个条件：
1、该类所有的实例已经被回收
2、加载该类的ClassLoder已经被回收
3、该类对应的java.lang.Class对象没有被引用，且没有在任何地方通过反射访问该类的方法。
JVM自带的根类加载器、扩展类加载器和系统类加载器，JVM本身会始终引用这些类加载器，因此条件2不会形成。而这些类加载器则会始终引用它们所加载的类对象，因此条件3也不会形成。
所以唯一会被卸载的类只有自定义的类加载器加载的类。
例题：
class A{
static int a;//类变量
String name;
int id;
//静态代码块
static{
a=10;
System.out.println("这是父类的静态代码块"+a);
}
//构造代码块
{
id=11;
System.out.println("这是父类的构造代码块id:"+id);
}
A(){
System.out.println("这是父类的无参构造函数");
}
A(String name){
System.out.println("这是父类的name"+name);
}
}
class B extends A{
String name;
static int b;
static{
b=12;
System.out.println("这是子类的静态代码块"+b);
}
B(String name) {
super();
this.name = name;
System.out.println("这是子类的name:"+name);
}
}
public class Test666 {
public static void main(String[] args) {
B bb=new B("GG");
}
}输出的结果如下：
这是父类的静态代码块10
这是子类的静态代码块12
这是父类的构造代码块id:11
这是父类的无参构造函数
这是子类的name:GG
Java程序对类的使用方式可分为两种：
(1) 主动使用
(2) 被动使用
所有的Java虚拟机实现必须在每个类或接口被Java程序“首次主动使用”时才会初始化他们(从加载开始)，其余情况都不会初始化只执行初始化前的步骤.
只有主动使用静态内部类才会开始内部类的生命周期，主动使用外部类只会开始外部类的生命周期。
主动使用:
① 创建类的实例
② 访问某个类或接口的静态变量，或者对该静态变量赋值
③ 调用类的静态方法
④ 反射(如Class.forName(“com.alibaba.Test”))
⑤ 初始化一个类的子类
⑥ Java虚拟机启动时被标明为启动类的类(Java Test)
类的初始化步骤：
(1) 假如一个类还没有被加载或者连接，那就先加载和连接这个类（此处还没有进行初始化）
(2) 假如类存在直接的父类，并且这个父类还没有被初始化，那就先初始化直接的父类
(3) 假如类中存在初始化语句，那就直接按顺序执行这些初始化语句
程序中对子类的“主动使用”会导致父类被初始化；但对父类的“主动”使用并不会导致子类初始化(不可能说生成一个Object类的对象就导致系统中所有的子类都会被初始化)
注：调用ClassLoader类的loadClass方法加载一个类，并不是对类的主动使用，不会导致类的初始化。
当java虚拟机初始化一个类时，要求它的所有的父类都已经被初始化，但这条规则并不适用于接口。
在初始化一个类时，并不会先初始化它所实现的接口.
在初始化一个接口时，并不会先初始化它的父接口.
例题：
package niuke;
public class TestStaticInitOrder {
public static void main(String[] args){
Singleton singleton = Singleton.getInstance();
System.out.println("counter1=" + singleton.counter1);
System.out.println("counter2=" + singleton.counter2);
}
}
class Singleton {
private static Singleton singleton = new Singleton();
public static int counter1=0;
public static int counter2;
static{
counter2 = 0;
}
private Singleton(){
counter1++;
counter2++;
}
public static Singleton getInstance(){
return singleton;
}
} 解析：程序开始运行，首先执行main方法，执行main方法第一条语句，调用Singleton类的静态方法，这里调用Singleton类的静态方法就是主动使用Singleton类。所以开始加载Singleton类。在加载Singleton类的过程中，首先对静态变量赋值为默认值。
Singleton=null
counter1 = 0
counter2 = 0
给他们赋值完默认值之后，要进行的就是对静态变量初始化，对声明时已经赋值的变量进行初始化。我们上面提到过，初始化是从类文件从上到下赋值的。所以首先给Singleton赋值，给它赋值，就要执行它的构造方法，然后执行counter1++;counter2++;所以这里的counter1 = 1;counter2 = 1;执行完这个初始化之后，先进行counter1的初始化，由于counter2没有被赋值，所以不进行初始化
此时：counter1=0；
counter2=1；
然后执行静态代码块后：
counter1=0；
counter2=0；