标签：
实例3
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two = new Two("two");
}
}
输出结果：
Test main() start...
one-1
one-2
one-3
two
在main()方法中实例化了一个Two类的对象。但程序在初始化Two类的对象时，并非先调用Two类的构造方法，而是先初始化Two类的成员变量。这里Two类有3个成员变量，它们都是One类的对象，所以要先调用3次One类的相应的构造方法。最后在初始化Two类的对象。
即在创建对象时，对象所在类的所有数据成员会首先进行初始化，如果其中的成员变量有对象，那么它们也会按照顺序执行初始化工作。在所有类成员初始化完成后，才调用对象所在类的构造方法创建对象。构造方法作用就是初始化。
示例4：
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}
输出结果：
Test main() start...
one-3
one-1
one-2
two-1
------------
one-1
one-2
two-2
如果一个类中有静态对象，那么它会在非静态对象前初始化，但只初始化一次。非静态对象每次调用时都要初始化。
实例5
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
One one_1 = new One("one-1");
One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
static Two two_3 = new Two("two-3");
public static void main(String[] args)
{
System.out.println("Test main() start");
Two two_1 = new Two("two-1");
System.out.println("------------");
Two two_2 = new Two("two-2");
}
}
输出结果：
one-3
one-1
one-2
two-3
Test main() start...
one-1
one-2
two-1
------------
one-1
one-2
two-2
程序中主类中的静态变量/静态对象会在main()方法执行前初始化。结果中只输出了一次one-3，这也说明：如果一个类中有静态对象，那么它会在非静态对象前初始化，但只初始化一次。非静态对象每次调用时都要初始化。
实例6
class One
{
One(String str)
{
System.out.println(str);
}
}
class Two
{
static int i = 0;
One one_1 = new One("one-1");
static One one_2 = new One("one-2");
static One one_3 = new One("one-3");
Two(String str)
{
System.out.println(str);
}
}
public class Test
{
public static void main(String[] args)
{
System.out.println("Test main() start");
System.out.println("Two.i = " Two.i);
}
}
输出结果：
Test main() start...
one-2
one-3
Two.i = 0
说明在同一个类的层次结构下：
不仅第1次创建对象时，类中所有的静态变量要初始化，第1次访问类中的静态变量（没有创建对象）时，该类中所有的静态变量也要按照它们在类中排列的顺序初始化。
说明：一般情况下，在主程序中是需要首先创建对象，然后才去访问对象的变量或者方法的，在此过程中是需要按照对象初始化的步骤走完所有流程的，走完之后，才能去访问特定的变量或者方法。
特殊情况下，在主程序中直接访问类变量或者类方法时，因为类变量和类方法是不依赖对象存在的，所以访问前，主程序中是不需要创建对象的（new）的，那么该程序的运行过程是：1.主程序类的
总结初始化顺序：
1．主类的静态成员首先初始化。
2．主类的父类的构造方法被调用。
3．主类的非静态对象（变量）初始化。
4．调用主类的构造方法。
初始化的顺序包括构造方法调用的顺序如下：
1．主程序类的静态成员（静态对象或变量））首先初始化。
2．主类的超类的构造方法按照从最高到最低(超类到主类)的顺序被调用，并且同时初始化的非静态成员（非静态对象或变量）即实例变量。
.构造函数：
当子类继承一个父类时，构造子类时需要调用父类的构造函数，存在三种情况
（1），父类无构造函数或者一个无参数构造函数，子类若无构造函数或者有无参数构造函数，子类构造函数中不需要显式调用父类的构造函数，系统会自动在调用子类构造函数前调用父类的构造函数
（2），父类只有有参数构造函数，子类在构造方法中必须要显式调用父类的构造函数，否则编译出错
（3），父类既有无参数构造函数，也有有参构造函数，子类可以不在构造方法中调用父类的构造函数，这时使用的是父类的无参数构造函数
3．调用主类的构造方法。
不存在继承关系各类中、不存在对象引用的对象创建初始化顺序
标签：
原文地址：http://www.cnblogs.com/lubocsu/p/5097551.html
