类的加载与对象创建过程
Java中每个类的编译代码都存在于他自己的独立的文件中。该文件只在需要使用程序代码时才会被加载初始化。一般来说“类的代码在初次使用时才加载”，这通常是指加载发生于创建类的第一个对象之时，但访问static域或static方法时，也会发生加载。
“初始化”和“创建”是捆绑在一起的，二者不能分离。假设有个名为Dog的类，那么该类的创建过程如：
- 即使没有显示地使用static关键字，构造器实际上也是静态方法。因此，当首次创建Dog的对象时，或者Dog的静态方法/静态域被首次访问时，Java解释器必须查找类路径，以定位Dog.class文件。
- 然后载入Dog.class,有关静态初始化的所有动作都会执行。因此，静态初始化只在Class对象首次加载的时候进行一次。
- 当用new创建Dog对象时,首先在堆上为Dog对象分匹配足够的存储空间。
- 这块存储空间会被清零，这就自动的将Dog对象中的所有基本类型设置成默认值，而引用类型被设置成了null。
- 执行所有出现于字段定义处的初始化动作。
- 执行构造器
构造器初始化
成员变量在声明后如果没有为其赋值，则编译器会默认为其赋上默认值，而局部变量则不会，在运行时如果局部变量没有初始化则会抛出异常。编译器在通过构造器创建对象的过程中发现该类中有成员变量，则先初始化成员变量然后再执行构造器的初始化内容。如：
public class Test {
int i ;
{
System.out.println(i); //构造代码块优先于构造方法执行
i++;
}
public Test (){
System.out.println(i);
}
public static void main(String[] args){
new Test();
}
}
输出：0; 1
我们可以用构造器来进行初始化，在运行时刻，可以调用方法或执行某些动作来确定初始值；但是，我们无法阻止自动初始化的进行，他将在构造器被调用之前发生。正如上面示例所见，成员变量先被初始化为0，然后变为1。
非静态数据初始化
在类的内部，变量定义的先后顺序决定了初始化的顺序。即使成员变量定义散布于方法之间，他们仍旧会在任何方法包括构造器执行之前得到初始化。例如：
class Window{
public Window(int marker){
System.out.println("Window ("+marker+")");
}
}
class House{
Window w1 = new Window(1);
public House(){
System.out.println("House()");
w3 = new Window(33);
}
Window w2 = new Window(2);
public void f(){
System.out.println("f()");
}
Window w3 = new Window(3);
}
public class Initialization {
public static void main(String[] args){
House h = new House();
h.f();
}
}
输出：
Window (1)
Window (2)
Window (3)
House()
Window (33)
f()
静态数据的初始化
无论创建多少个对象，静态数据只占用一份存储区域。static关键字不能应用于局部变量，因此它只能作用于域。如果一个域是基本类型域，而且也没有对它进行初始化，那么它就会获得基本类型的初始值；如果是引用对象，那么它的默认初始值就是null。下面的示例说明静态域是如何初始化的。
class Bowl {
public Bowl(int marker) {
System.out.println("Bowl(" + marker + ")");
}
public void f1(int marker) {
System.out.println("f1(" + marker + ")");
}
}
class Table {
static Bowl bowl = new Bowl(1);
public Table() {
System.out.println("Table()");
bow2.f1(1);
}
public void f2(int marker) {
System.out.println("f2(" + marker + ")");
}
static Bowl bow2 = new Bowl(2);
}
class Cupboard {
Bowl bowl3 = new Bowl(3);
static Bowl bowl4 = new Bowl(4);
public Cupboard() {
System.out.println("Cupboard()");
bowl4.f1(2);
}
public void f3(int marker) {
System.out.println("f3(" + marker + ")");
}
static Bowl bowl5 = new Bowl(5);
}
public class StaticInitialization {
public static void main(String[] args) {
System.out.println("Creating new Cupboard() in main 1");
new Cupboard();
System.out.println("Creating new Cupboard() in main 2");
new Cupboard();
table.f2(1);
cupboard.f3(1);
}
static Table table = new Table();
static Cupboard cupboard = new Cupboard();
}
输出：
Bowl(1)
Bowl(2)
Table()
f1(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main 1
Bowl(3)
Cupboard()
f1(2)
Creating new Cupboard() in main 2
Bowl(3)
Cupboard()
f1(2)
f2(1)
f3(1)
Bowl类是的看到类的创建，而Table类和Cupboard类在它们的类定义中加入了Bowl类型的静态成员变量。注意，在静态数据定义之前，Cupboard类先定义了一个Bowl类型的非静态数据成员bowl3.
由输出可见，静态初始化只有在必要时刻才会进行。如果不创建Table对象，也不引用Table.bowl1或Table.bowl2,那么静态的Bowl bowl1和bowl2永远都不会被创建，只有在第一个Table对象被创建（或者第一次访问静态数据）的时候，它们才会被初始化。此后，静态数据不会再被初始化。
类的初始化顺序：先静态对象（如果它们未因前面的对象创建过程而被初始化），然后非静态对象。从输出结果可以这看出这一点。要执行main()方法，必须加载StaticInitialization类，然后静态域table和cupboard被初始化，这导致它们对应的类也被加载，并且由于它们包含静态的Bowl对象，因此Bowl随后也被加载，这样在这个特殊的程序中，所有类在main()开始之前就都被夹在了。实际开发中遇到这样的情况很少。
数组初始化
数组只是相同类型的，用一个标识符名称封装到一起的一个对象序列或基本类型数据序列。类似于 int[] arr 和 int arr[]都称之为数组；由于编译器不允许指定数组大小，所以我们现在拥有的只是对数组的一个引用（我们已经为该引用分配了足够的内存空间），而且没有给数组对象本身分配任何空间。为了给创建相应的存储空间，必须写初始化表达式。数组可以用类似于：int[] arr = {1,2,3};这样特殊的方式初始化。
在Java中可以将一个数组赋值给另一个数组：
int[] a1 = {1,2,3,4,5};
int[] a2;
a2 = a1;
其实这是只是复制了一个引用，就像下面这样：
public class ArrayTest {
public static void main(String[] args) {
int[] a1 = {1, 2, 3, 4, 5};
int[] a2;
a2 = a1;
for (int i = 0; i < a2.length; i++) {
a2[i] = a2[i] + 1;
}
for (int i = 0; i < a1.length; i++) {
System.out.println("a1[" + i + "]= " + a1[i]);
}
}
}
输出：
a1[0]= 2
a1[1]= 3
a1[2]= 4
a1[3]= 5
a1[4]= 6
有以上实例可以看出，a1有初始值，a2没有，把a1赋值给a2后，由于a1和a2都是相同数组的别名，所以a2对数组做的修改在a1中也能看到。所有数组中都有一个固定成员，那就是length，这与String里获取长度的方法不同，String是length()方法，不是成员。
数组的创建发生在运行时期，所以在编译时期不能确定数组里需要多少个元素，可以直接用new在数组里创建元素。尽管创建的是基本数据类型数组，new任然可以工作。如：
public class ArrayTest {
public static void main(String[] args) {
int[] a;
Random random = new Random(12324);
a = new int[random.nextInt(20)]; //产生0到20之间的一个随机数
System.out.println("length of a = "+a.length);
System.out.println(Arrays.toString(a));
}
}
输出：
length of a = 12
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
如果可能的话尽量在数组定义时就初始化。
继承与初始化
class Insect {
private int i = 9;
protected int j;
public Insect() {
System.out.println("i = " + i + " ,j = " + j);
j = 39;
}
private static int x1 = printInit("static Insect.x1 initialized");
public static int printInit(String s) {
System.out.println(s);
return 47;
}
}
public class Beetle extends Insect {
private int k = printInit("Beetle.k initialized");
public Beetle() {
System.out.println("k= " + k);
System.out.println("j= " + j);
}
private static int x2 = printInit("static Beetle.x2 initialized");
public static void main(String[] srgs) {
System.out.println("Beetle constructor");
Beetle beetle = new Beetle();
}
}
输出：
static Insect.x1 initialized
static Beetle.x2 initialized
Beetle constructor
i = 9 ,j = 0
Beetle.k initialized
k= 47
j= 39
从以上实例可以得知：程序运行后的第一件事就是试图访问Beetle的main方法，于是加载器开始启动并找到Beetle类的编译代码。在对它进行加载的过程中发现它有一个基类，于是他继续进行加载。即使在Beetle类中没有创建该基类对象，这也会发生。如果该基类还有它自身的基类，那么第二个基类就会被加载，如此类推。接下来，根基类中的static初始化，然后是下一个导出类(子类)，如此类推。这种方式很重要，因为导出类的static初始化可能依赖于基类成员是否被正确初始化。
参考自《Java编程思想》
