此为大牛写好后，我转载过来的，内容包括多位大牛对java中程序执行顺序的思考！
- * 几大原则
- * 一、静态成员变量（Static）
- * 1、静态成员变量为类变量，所有对象共享同一内存空间
- * 2、静态成员变量的声明和定义仅在首次加载类时执行一次
- * 3、首次加载类时首先对所有静态成员变量根据类型默认赋初值，然后再对有右值的附右值
- * 二、静态初始块
- * 1、静态初始化块仅在首次加载类时执行一次
- * ······多个静态成员变量与静态始化快参照出现顺序先后执行······
- * 三、动态成员变量
- * 1、动态成员变量定义在每次实例化对象时在构造函数之前执行
- * 四、动态初始化块
- * 1、动态初始化块在每次实例化对象时在构造函数之前执行
- * ······多个动态成员变量与动态初始化块参照出现顺序先后执行······
- * 总结：总的来说，在不涉及继承的前提下，当首次加载类时，按照如下顺序执行
- * 1、按照出现顺序先后执行静态成员变量定义与静态初始化块
- * 2、按照出现顺序先后执行动态成员变量定义与动态初始化块
- * 3、执行构造函数
- * 再次实例化对象时只执行第2、3步即可
- *
- * ············成员变量与定义与初始化块先于构造函数执行·········
- * 五、当涉及到继承时，按照如下顺序执行
- * 1、执行父类的静态成员变量定义与静态初始化块，执行子类的静态成员变量定义与静态初始化块
- * 2、执行父类的非静态成员变量定义与动态初始化块，执行父类构造方法
- * 3、执行子类的非静态成员变量定义与动态初始化块，执行子类构造方法
- * 另：父类构造方法中用到的方法如果已被子类重写，那么在构造子类对象时在调用父类构造函数中使用子类重写的方法
一、先执行内部静态对象的构造方法，如果有多个按定义的先后顺序执行；静态对象在构造的时候也是也先执行其内部的静态对象。
二、再调用父类的构造方法（父类还有父类的话，从最开始的基类开始调用），如果没有明显指定调用父类自定义的构造方法，那么编译器会调用默认的父类构造方法super()。但是如果要调用父类自定义的构造方法，要在子类的构造方法中明确指定。
三、按声明顺序将成员引用对象变量初始化。
四、最后调用自身的构造方法。
下面以一个例子来说明代码如下：
1. class Animal{
2. String name;
3. Animal() {
4. "class Animal");
5. }
6. Animal(String name){
7. this.name = name;
8. " class Animal");
9. printNumber();
10. }
11.
12. public void printNumber(){
13.
14. }
15. }
16.
17. class Fish extends Animal{
18. Fish() {
19. "class Fish");
20. }
21. }
22.
23. class GoldFish extends Fish {
24. GoldFish() {
25. "class GoldFish");
26. }
27. }
28.
29. class Cat {
30. Cat(){
31. "class cat");
32. }
33. }
34.
35. class Rabbit {
36. private static int number;
37. private static Cat cat = new Cat();
38. public Rabbit() {
39. number++;
40. "class rabbit");
41. }
42. }
43.
44. class Dog extends Animal{
45. public int dogNumber;
46. private GoldFish goldFish = new GoldFish();
47. static Rabbit blackRabbit = new Rabbit();
48. static Rabbit whiterabbit = new Rabbit();
49.
50. public Dog() {
51. super("Tom");
52. "class Dog");
53. 10;
54. "The dog's number is:" + dogNumber);
55. }
56.
57. public void printNumber(){
58. "The dog's number is:" + dogNumber);
59. }
60. }
61.
62. public class TestInheritanceConstructor extends Animal {
63. public static void main(String[] args){
64. new Dog(); //Test the executive order of constructor
65. }
66. }
67. 执行结果：
class cat
1class rabbit
2class rabbit
Tom class Animal
The dog's number is:0
class Animal
class Fish
class GoldFish
class Dog
The dog's number is:10解释：
输出：class cat 是因为Dog类中有静态成员。而静态成员所在的类Rabbit中又有静态成员。所以最先执行它。验证第 一句。
输出：1class rabbit 和 2class rabbit 是执行类Rabbit构造函数。
输出：Tomclass Animal 执行父类的构造函数，因为用super("")。
输出：The dog's number is:0 可以看出子类的dogNumber还是默认值0
输出：class Animal 和 class Fish 和 class GoldFish是构造goldFish引用对象类型。验证第三句。
输出：class Dog 和The dog's number is:10是执行自己的构造函数。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
