初始化其实就是为变量分配内存空间，并确定其初始值的过程。
先看哪些东西需要初始化，可以初始化
1.构造器
2.static语句块
3.类的变量
其中类的变量又可以分为，局部变量(方法中的)，静态变量和普通变量。
现在来讨论一下他们是怎样初始化，又是以什么样的顺序初始化。
先看以下代码(来自Pickuper)
packageTest;importjava.awt.peer.SystemTrayPeer;classA {public A(inti) {
System.out.println("A"+i+" was created!");
}
}classB {public B(inti) {
System.out.println("Static B"+i+" was created!");
}
}classBaseClass {
A a= new A(1);static{
System.out.println("BaseClass's first static block was execute!");
}static B b = new B(2);static{
System.out.println("BaseClass's second static block was execute!");
}publicBaseClass() {
System.out.println("BaseClass's constructor was called!");
}
A aa= new A(3);static B bb = new B(4);
}class ChildClass extendsBaseClass {
A aaa= new A(5);static{
System.out.println("ChildClass's first static block was execute!");
}static B bbb = new B(6);static{
System.out.println("ChildClass's second static block was execute!");
}publicChildClass() {
System.out.println("ChildClass's constructor was called!");
}
A aaaa= new A(7);static B bbbb = new B(8);
}public class初始化测试初始化顺序 {/***@paramargs*/
public static voidmain(String[] args) {
System.out.println("Enter the main function!");
ChildClass childClass= newChildClass();
System.out.println("Leave the main function!");
}
}
/*
输出：
Enter the main function!
BaseClass's first static block was execute!
Static B2 was created!
BaseClass's second static block was execute!
Static B4 was created!
ChildClass's first static block was execute!
Static B6 was created!
ChildClass's second static block was execute!
Static B8 was created!
A1 was created!
A3 was created!
BaseClass's constructor was called!
A5 was created!
A7 was created!
ChildClass's constructor was called!
Leave the main function!
*/
从中，我们可以得到一些关于优先级的结论：
1.static变量和static语句块优于普通变量和构造函数先执行，而普通变量有优于构造方法先执行，这个是第一原则。
2.父类和子类的问题了，有父类就优先执行父类，这是第二原则。第一原则执行时，兼顾第二原则。这里解释“兼顾第二原则”的意思一下，上述代码中是优先执行static变量和static语句块，并且优先执行父类中的static变量和static语句块，再执行子类的static变量和static语句块。接着执行普通变量的初始化，还是父类优先……
但是仔细的同志会发现，static变量和static语句块是父类执行完，就直接执行子类。而普通变量和构造方法有点不同，他们俩的优先级差的没那么多，普通变量在父类初始化完后，并不是回到子类接着初始化，而是构造器去父类初始化了，这一点与static不同。
鉴于对static语句块不熟悉，我做了个小测试。看以下代码。
packageTest;classCat{static{
System.out.println("静态代码段先于构造函数运行而且只运行一次，同时父类的优先级最高先被初始化。");
System.out.println("-------{我是猫，狗狗他爸，我数一二三，儿子你再叫汪汪}");
System.out.println("-------1，2，3！！！");
}
}class Dog extendsCat{publicDog(){
System.out.println("我是构造函数，我比静态代码优先级低");
}public Dog(inti){
System.out.println("验证静态代码只运行一次,静态块只在类声明时执行，类实例化时将不再调用，狗不叫就说明是真的！！！");
}static{
System.out.println("-------汪汪");
}
}public class静态代码段测试 {public static voidmain(String[] args) {
Dog dog=newDog();
Dog dog2=new Dog(2);
}
}
/*输出
静态代码段先于构造函数运行而且只运行一次，同时父类的优先级最高先被初始化。
-------{我是猫，狗狗他爸，我数一二三，儿子你再叫汪汪}
-------1，2，3！！！
-------汪汪
我是构造函数，我比静态代码优先级低
验证静态代码只运行一次,静态块只在类声明时执行，类实例化时将不再调用，狗不叫就说明是真的！！！
*/
这段代码恶搞部分忽略…静态代码段今天才接触，先看一下他的特点：
1:静态代码段先于构造函数运行而且只运行一次，同时父类的优先级最高先被初始化。
注：后半句在上部分已说明，重点在前半句----“一次”。仔细看代码，狗没叫诶，验证完毕。
2.其实我试过，将
Dog dog=newDog();
Dog dog2=new Dog(2);
这两句话注释掉，结果没输出。我就比较疑惑，什么时候才会类声明呢？对于“静态块只在类声明时执行”这句话，我好桑心…于是我百度了。
请看下面两段话(来自百度)：
静态块的特点是在类加载的时候就执行，先说一下类加载，一个程序要想运行，首先要把代码加载到内存中对吧？然后才能去和CPU交流，这是冯诺依曼计算机规定的。Java也是一样，Java的.class字节码文件要想执行，首先也要加载到内存，由类加载器把字节码文件的代码加载到内存中，这一步就叫类加载，这是首先要进行的。
当创建Test类的一个对象的时候，比如new Test() ,是这样，首先是类加载，然后才能new对象，静态块在类加载的时候就执行了，这就说明静态块在new对象之前就会执行，而且一个类在第一次被使用的时候会被加载，然后在整个应用程序的生命周期当中不会再次被加载了，就加载这一次，所以这就说明，静态块就执行一次，不会执行第二遍！
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
