JAVA中类的初始化
Person p = new Person("zhangsan",20);该句话都做了什么事情？
1，因为new用到了Person.class.所以会先找到Person.class文件并加载到内存中。
2，执行该类中的static代码块，如果有的话，给Person.class类进行初始化。
3，在堆内存中开辟空间，分配内存地址。
4，在堆内存中建立对象的特有属性。并进行默认初始化。
5，对属性进行显示初始化。
6，对对象进行构造代码块初始化。
7，对对象进行对应的构造函数初始化。
8，将内存地址付给栈内存中的p变量。
这是今天在视频中老师讲到的，我在看完又在网上搜了有关于初始化的文章。下面就是收获。
初始化其实包含两部分：类的初始化和对象的创建
因为类的加载肯定是第一步的，所以类的初始化在前。大体的初始化顺序是：
类初始化 ->子类构造函数 ->父类构造函数 ->实例化成员变量 ->继续执行子类构造函数的语句。
类的初始化
类的初始化包括：初始化类和初始化接口。例如
class Super {
static String s = “static field”; //初始化静态变量
// 执行静态代码块
static {
System.out.println(“This is static initializer”);
}初始化类是指初始化静态变量和执行static初始化块。
初始化接口是初始化定义在该接口中的变量
注意
初始化类时，该类的父类将首先被初始化，但其实现的接口则不会。
初始化类时，该类的父类，以及父类的父类会首先被递归初始化，一直到java.lang.Object为止，但初始化接口时候，则不需要如此，只会初始化该接口本身。
对于由引用类变量所引发的初始化，只会初始化真正定义该变量的类。
如果一个静态变量是编译时常量，则对它的引用不会引起定义它的类的初始化。
public class Initialization {
public static void main(String[] args) {
System.out.println(Sub.x); //
// 不会引起Sub类的初始化，因为x是定义在Super类中的
System.out.println("-------------------------");
System.out.println(Sub.y);
// 不会引起Sub类的初始化，因为y是常量
System.out.println("-------------------------");
System.out.println(Sub.z = 2004);
// 将会引起Sub的初始化
}
}
class Super{
static int x = 2006;
}
class Sub extends Super {
static final int y = 2005;
static int z;
static {
System.out.println("Initialization Sub");
}
}对象的创建
对象的创建，具备步骤如下：
1.所有的成员变量—包括该类，及它的父类中的成员变量--被分配内存空间，并赋予默认值。（这里是第一次初始化成员变量）
2. 为所调用的构造函数初始化其参数变量。（如果有参数）
3.如果在构造函数中用this调用了同类中的其他构造函数，则按照步骤(2)~(5)去处理被调用到的构造函数。
4.如果在构造函数中用super调用了其父类的构造函数，则按照步骤(2)~(5)去处理被调用到的父类构造函数。
5按照书写顺序，执行instance initializer和 instance variable initializer来初始化成员变量。（这里是第二次初始化成员变量）
注意：成员变量其实被初始化2次，第一次是赋予默认值，第二次才是你设的值
最后看一个例子
public class InitializationOrder {
public static void main(String[] args) {
Subclass sb = new Subclass();
}
}
class Super{
static {
System.out.println(1);
}
Super(int i){
System.out.println(i);
}
}
class Subclass extends Super implements Interface{
static {
System.out.println(2);
}
Super su = new Super(4);
Subclass() {
super(3);
new Super(5);
}
}
interface Interface{
static Super su = new Super(0);
}首先，Java虚拟机要执行InitializationOrder类中的static方法main()，这引起了类的初始化。开始初始化InitializationOrder类。具体的步骤略去不说。
接着，InitializationOrder类初始化完毕后，开始执行main()方法。语句Subclass sb = newSubclass()将创建一个Subclass对象。加载类Subclass后对其进行类初始化，但因为Subclass有一个父类Super，所以先初始化Super类，初始化块static {System.out.println(1);}被执行，打印输出1；
第三，Super初始化完毕后，开始初始化Subclass类。static {System.out.println(2);}被执行，打印输出2；
第四，至此，类的加载工作全部完成。开始进入创建Subclass的对象过程。先为Subclass类和其父类Super类分配内存空间，这时Super su 被附值为null;
第五，执行构造函数Subclass()时，super(3)被执行。如前面(d)所说，Super类的构造函数Super(int i){….}被调用，并按照步骤(b)~(f)来处理。因此，递归调用Super类的父类Object类的构造函数，并按照步骤(b)~(f)来初始化Object类，不过没有任何输入结果。最后打印输出3；
第六，如前面(e)所说，初始化成员变量su，其结果是打印输出4；
第七，如前面(f)所说，执行new Super(5)，并打印输出5；
最后，Subclass虽然实现了接口Interface，但是初始化它的时候并不会引起接口的初始化，所以接口Interface中的static Super su = newSuper(0)自始至终都没有被执行到。
最后的最后附上Java类中类属性 (static 变量) 和对象属性 (非 static 变量) 的初始化顺序
public class Bolg{
static String a = "string-a";
static String b;
String c = "stirng-c";
String d;
static {
printStatic("before static"
);
b = "string-b";
printStatic("after static");
}
public static void printStatic(String title) {
System.out.println("---------" + title + "---------");
System.out.println("a = \"" + a + "\"");
System.out.println("b = \"" + b + "\"");
}
public Bolg() {
print("before constructor");
d = "string-d";
print("after constructor");
}
public void print(String title) {
System.out.println("---------" + title + "---------");
System.out.println("a = \"" + a + "\"");
System.out.println("b = \"" + b + "\"");
System.out.println("c = \"" + c + "\"");
System.out.println("d = \"" + d + "\"");
}
public static void main(String[] args) {
new Bolg();
}由此可以看出java 类属性和对象属性的初始化顺序如下：
① 类属性 (静态变量) 定义时的初始化，如上例的 static String a = "string-a";
② static 块中的初始化代码，如上例 static {} 中的 b = "string-b";
③ 对象属性 (非静态变量) 定义时的初始化，如上例的 String c = "stirng-c";
④ 构造方法 (函数) 中的初始化代码，如上例构造方法中的 d = "string-d";
