java程序的执行顺序

笔试的时候发现这样一道题，发现自己对于java的一些基础还是有所欠缺，于是在笔试后专门自己动手实现了下。

import java.util.*;

class helloA{
	public helloA(){
	System.out.println("helloA");
	}
	{
	System.out.println(" I am  class A");
	}
	static{
		System.out.println(" static A");
	}
}
public final class helloB extends helloA{
	public helloB(){
	System.out.println("helloB");
	}
	{
	System.out.println(" I am  class B");
	}
	static{
		System.out.println(" static B");
	}
	public static void main(String args[]){
		helloB b;
		helloB a;
		helloB c;
	   new helloB();
	}
}

程序执行结果是：

static A
static B
I am  class A
helloA
I am  class B
helloB

也就是说，执行顺序是

1.    父类静态块
2.    自身静态块
3.    父类块
4.    父类构造器
5.    自身块
6.    自身构造器 

上网搜了一下，网上也有不少这类的文章，关于这个执行顺序还有一篇文章降到了赋值的顺序，这里也一并给出：

class Dog {  
    public String type="父类成员变量赋的值";  
    public Dog() {  
        System.out.println("父类构造器--type-->"+type);  
        type="父类构造器赋的值";  
                   System.out.println("父类构造器----type--->"+type);  
    }  
      
    {  
        System.out.println("block---type--->"+type);  
        type="父类块赋的值";  
    }  
}  
public class Mastiff extends Dog {  
    public String type="成员变量赋的值";  
    public Mastiff() {  
        System.out.println("构造器---type--->"+type);  
        type="构造器赋的值";  
    }  
      
    public void say(){  
        System.out.println("say---type---->"+type);  
    }  
  
    {  
        System.out.println("block---type--->"+type);  
        type="块赋的值";  
          
    }  
      
    public static void  main(String[] args){  
        Mastiff mastiff=new Mastiff();  
        mastiff.say();
    }  
}  

执行结果是：

block---type--->父类成员变量赋的值
父类构造器--type-->父类块赋的值
父类构造器----type--->父类构造器赋的值
block---type--->成员变量赋的值
构造器---type--->块赋的值
say---type---->构造器赋的值

也就是说赋值顺序是：

1. 父类成员变量赋值
2. 父类块赋值
3. 父类构造器赋值
4. 自身成员变量赋值
5. 自身块赋值
6. 自身构造器赋值

结合我们前面说的程序中的执行顺序，这个显然是很好理解的：
1.成员变量赋值>>>块赋值>>>构造器赋值
2.父类的块>>父类构造器>>自身块>>自身构造器

又因为一个成员变量是不可能在静态变量中赋值的，而且又前面程序执行顺序可知

     静态块>>块

所以，程序的赋值步骤为

1. 父类的静态变量赋值
2. 自身的静态变量赋值
3. 父类成员变量赋值
4. 父类块赋值
5. 父类构造器赋值
6. 自身成员变量赋值
7. 自身块赋值
8. 自身构造器赋值