java 任务按顺序执行 java编写顺序

转载

智能开发者 2023-07-17 17:32:44

文章标签 java 任务按顺序执行父类赋值构造器 文章分类 Java 后端开发

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

一.JAVA中执行顺序

静态块
块
构造器
父类构造器

二.JAVA中赋值顺序

静态块直接赋值
块直接赋值
父类继承的属性已赋值
静态变量声明时赋值
成员变量声明时赋值
构造器赋值

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

獒类

的Java代码

1. <span style =“font-size：medium;”> / ** 
2.  *子类藏獒 
3.  * /  
4. 公共班级獒犬延伸狗{  
5.     公共獒（）{  
6.         的System.out.println（ “獒”）;  
7.     }  
8.   
9.     {  
10.         的System.out.println（ “块”）;  
11.     }  
12.     静态的 {  
13.         System.out.println（“static block”）;  
14.     }  
15.       
16.     public static void main（String [] args）{  
17.         獒藏獒=新獒犬（）;  
18.           
19.     }  
20. }  
21. </跨度>

狗类

的Java代码

1. <span style =“font-size：medium;”> / ** 
2.  * DOG父类 
3.  * /  
4. 公开课狗{  
5.     公众狗（）{  
6.         的System.out.println（ “狗”）;  
7.     }  
8. }  
9. </跨度

运行结果为：

静态块狗块獒

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

静态块
父类构造器
本类中的块
本类的构造器

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

DOG类改进后源码

Java代码

1. <span style="font-size: medium;">/** 
2.  *DOG父类 
3.  */  
4. public class Dog {  
5.     public Dog() {  
6.         System.out.println("Dog");  
7.     }  
8.     static{  
9.         System.out.println("super static block");  
10.     }  
11.       
12.     {  
13.         System.out.println("super block");  
14.     }  
15. }  
16. </span>

Mastiff改进后源码

Java代码

1. <span style="font-size: medium;">/** 
2.  * 子类藏獒 
3.  */  
4. public class Mastiff extends Dog {  
5.     public Mastiff() {  
6.         System.out.println("Mastiff");  
7.     }  
8.   
9.     {  
10.         System.out.println("block");  
11.           
12.     }  
13.     static {  
14.         System.out.println("static block");  
15.     }  
16.       
17.     public static void  main(String[] args){  
18.         Mastiff mastiff=new Mastiff();        
19.     }  
20. }  
21. </span>

运行的结果为：

super static block static block super block Dog block Mastiff

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

父类静态块
自身静态块
父类块
父类构造器
自身块
自身构造器

好了，知道了运行的顺序，那么这是为什么呢？这就要从JVM中类的装载机制和实例化机制开始说起，这里因为主题原因，先不讨论，有兴趣的同学可以自己查资料。

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

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

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

Java代码

1. <span style="font-size: medium;">/** 
2.  *DOG父类 
3.  */  
4. public class Dog {  
5.     public String type="父类成员变量赋的值";  
6.     public Dog() {  
7.         System.out.println("父类构造器--type-->"+type);  
8.         type="父类构造器赋的值";  
9.                    System.out.println("父类构造器----type--->"+type);  
10.     }  
11.       
12.     {  
13.         System.out.println("block---type--->"+type);  
14.         type="父类块赋的值";  
15.     }  
16. }  
17. </span>

Java代码

1. <span style="font-size: medium;">/** 
2.  * 子类藏獒 
3.  */  
4. public class Mastiff extends Dog {  
5.     public String type="成员变量赋的值";  
6.     public Mastiff() {  
7.         System.out.println("构造器---type--->"+type);  
8.         type="构造器赋的值";  
9.     }  
10.       
11.     public void say(){  
12.         System.out.println("say---type---->"+type);  
13.     }  
14.   
15.     {  
16.         System.out.println("block---type--->"+type);  
17.         type="块赋的值";  
18.           
19.     }  
20.       
21.     public static void  main(String[] args){  
22.         Mastiff mastiff=new Mastiff();  
23.         mastiff.say()</span><span style="font-size: medium;">;</span><span style="font-size: medium;">        
24.     }  
25. }  
26. </span>

执行结果如下：

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

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