JAVA程序执行顺序，你了解了吗？_JAVA_编程开发_程序员俱乐部

本文主要介绍以下两块内容的执行顺序，熟悉的大虾可以直接飘过。

? ? ?一。JAVA中执行顺序

1. 静态块
2. 块
3. 构造器
4. 父类构造器

? ? 二。JAVA中赋值顺序

1. ? ? ? 静态块直接赋值
2. ? ? ? 块直接赋值
3. ? ? ? 父类继承的属性已赋值
4. ? ? ? 静态变量声明时赋值
5. ? ? ? 成员变量声明时赋值
6. ? ? ? 构造器赋值

?

?第一部分很好测试，我们只需要写一个子类，类中定义一个静态块，一个普通块，一个构造器，它的父类构造器，都打印一条语句，即可明白它们直接的执行顺序

?

Mastiff类

?

/**
 * 子类藏獒
 */
public class Mastiff extends Dog {
	public Mastiff() {
		System.out.println("Mastiff");
	}

	{
		System.out.println("block");
	}
	static {
		System.out.println("static block");
	}
	
	public static void  main(String[] args){
		Mastiff mastiff=new Mastiff();
		
	}
}

?

?

? DOG类

?

/**
 *DOG父类
 */
public class Dog {
	public Dog() {
		System.out.println("Dog");
	}
}

?

运行结果为：

?

也就是说，在我们的程序中，实例化一个类对象的时候，运行顺序为：

1. ? 静态块
2. ? 父类构造器
3. ? 本类中的块
4. ? 本类的构造器?

我们可以更进一步，如果在父类中也有块和静态块呢？

? ? DOG类改进后源码?

/**
 *DOG父类
 */
public class Dog {
	public Dog() {
		System.out.println("Dog");
	}
	static{
		System.out.println("super static block");
	}
	
	{
		System.out.println("super block");
	}
}

??

? ?Mastiff改进后源码

/**
 * 子类藏獒
 */
public class Mastiff extends Dog {
	public Mastiff() {
		System.out.println("Mastiff");
	}

	{
		System.out.println("block");
		
	}
	static {
		System.out.println("static block");
	}
	
	public static void  main(String[] args){
		Mastiff mastiff=new Mastiff();		
	}
}

?

运行的结果为：

?也就是说此时的运行顺序为：

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

?

? 好了，知道了运行的顺序，那么这是为什么呢？

? ? ? ? ?这就要从JVM中类的装载机制和实例化机制开始说起，这里因为主题原因，先不讨论，有兴趣的同学可以自己查资料。

?

我们再来讨论第二个问题，一个变量的值，它有可能在哪些地方确定呢？？

1. 从父类继承该值（包括：1.作为父类的成员变量已经赋值 ?2.在父类的块中赋值 ?3.在父类的构造器中赋值）
2. 在构造器中对其进行赋值
3. 在块中进行赋值
4. 在方法调用中进行赋值

? 现在假设在我们刚刚的例子中，有一个变量type，表示狗的品种

?

/**
 *DOG父类
 */
public 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();		
	}
}

? ?

?

?执行结果如下：

?

答案很明显，赋值顺序为：

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

?

?

?结合我们前面说的程序中的执行顺序，这个显然是很好理解的：

? ?1.成员变量赋值>>>块赋值>>>构造器赋值

? ?2.父类的块>>父类构造器>>自身块>>自身构造器

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

? ? 静态块>>块

?

?

所以，程序的赋值步骤为

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

?