Java之初始化语句执行顺序

叁歲伎倆 2024-04-20 10:14 58阅读 0赞

### 文章目录 ###

*   *   *  一、非继承状态下
         *   *  1.无静态变量
             *  2.只存在静态变量
             *  3.成员变量与静态变量同时存在
         *  二、继承情况下
         *  三、为什么是这样的顺序?

当我们执行`className object = new ClassName()`时候代码执行的顺序为何？

### 一、非继承状态下 ###

#### 1.无静态变量 ####

**1.1——**

public class OrderTest {
    
        public OrderTest(){
            System.out.println("构造器被调用");
        }
    
        private int num = init();
    
        {
            System.out.println("代码块被调用");
        }
    
        private int init() {
            System.out.println("变量赋值");
            return 5;
        }
    
        public static void main(String[] args) {
            new OrderTest();
        }
    }

**打印结果——**:

变量赋值
    代码块被调用
    构造器被调用

**1.2 将构造代码块与变量定义交换位置——**

public OrderTest(){
            System.out.println("构造器被调用");
        }
    
        {
            num = 6;
            System.out.println("代码块被调用");
        }
    
        private int num = init();
    
        private int init() {
            System.out.println("变量赋值");
            return 5;
        }
    
        public static void main(String[] args) {
            new OrderTest();
        }

**打印结果——**:

代码块被调用
    变量赋值
    构造器被调用

**结论:**  
1.构造器总是在最后被调用  
2.成员变量的声明与代码块的执行顺序与他们在类中的先后顺序有关.

#### 2.只存在静态变量 ####

**2.1——**

public class OrderTest1 {
    
        public OrderTest1(){
            System.out.println("构造方法调用");
        }
    
        private static int a = inita();
    
        static {
            System.out.println("静态代码块调用");
        }
    
        private static int inita(){
            System.out.println("初始化方法调用");
            return 10;
        }
    
        public static void main(String[] args) {
            new OrderTest1();
        }
    }

**打印结果——**:

初始化方法调用
    静态代码块调用
    构造方法调用

**2.2 将静态变量定义与静态代码块交换位置**

public class OrderTest1 {
    
        public OrderTest1(){
            System.out.println("构造方法调用");
        }
    
        static {
            System.out.println("静态代码块调用");
        }
    
        private static int a = inita();
    
        private static int inita(){
            System.out.println("初始化方法调用");
            return 10;
        }
    
        public static void main(String[] args) {
            new OrderTest1();
        }
    }

**打印结果——**:

静态代码块调用
    初始化方法调用
    构造方法调用

**结论:**  
(1) 构造方法总是最后被调用  
(2) 静态变量的声明与静态代码块的执行顺序与他们在类中定义的顺序有关.

#### 3.成员变量与静态变量同时存在 ####

public class OrderTest3 {
    
        private int num = init();
        private static String str = initStatic();
    
        public OrderTest3() {
            System.out.println("构造器执行");
        }
    
        {
            System.out.println("普通代码块执行");
        }
    
        static {
            System.out.println("静态代码块执行");
        }
    
        private int init(){
            System.out.println("成员变量初始化");
            return 6;
        }
    
        private static String initStatic(){
            System.out.println("静态变量初始化");
            return "hello";
        }
    
        public static void main(String[] args) {
            new OrderTest3();
        }
    }

**打印结果——**:

静态变量初始化
    静态代码块执行
    成员变量初始化
    普通代码块执行
    构造器执行

**结论:**  
(1) 构造器总是最后执行  
(2) (静态变量、静态块) > (成员变量、普通方法块) > 构造方法

(3) 静态变量声明、静态块执行顺序与定义的顺序有关;  
成员变量声明、普通方法块执行顺序与定义顺序有关;

简单粗暴的来说——  
将这些元素分为3组(静态成员变量声明、静态块)、(成员变量声明、普通方法块)、(构造方法). 然后对其进行排序.

### 二、继承情况下 ###

// OrderTest3 就是上一段代码
    
    public class OrderTest4 extends OrderTest3 {
       
        private int num = init();
        private static String str = initStatic();
    
        public OrderTest4() {
            System.out.println("子类构造器执行");
        }
    
        {
            System.out.println("子类普通代码块执行");
        }
    
        static {
            System.out.println("子类静态代码块执行");
        }
    
        private int init(){
            System.out.println("子类成员变量初始化");
            return 6;
        }
    
        private static String initStatic(){
            System.out.println("子类静态变量初始化");
            return "hello";
        }
    
        public static void main(String[] args) {
            new OrderTest4();
        }
    }

打印:

静态变量初始化
    静态代码块执行
    子类静态变量初始化
    子类静态代码块执行
    成员变量初始化
    普通代码块执行
    构造器执行
    子类成员变量初始化
    子类普通代码块执行
    子类构造器执行

**结论:**  
1.父类(静态变量声明、静态块) —> 子类(静态变量声明、静态块) —>父类(成员变量声明、普通代码块) —>  
父类(构造器) —>子类(成员变量声明、普通代码块) —>子类(构造器)  
2.变量声明、代码块执行顺序与它们在类中定义的先后顺序相关  
3.子类构造器总是最后执行

**再精简一下**:  
父类静态 —> 子类静态 —> 父类(成员变量声明、普通代码块 —> 构造方法 ) —> 子类(成员变量声明、普通代码块 —> 构造方法 )

**Last:**  
静态(父类，子类) —> 父类(非静态) —> 子类(非静态)

### 三、为什么是这样的顺序? ###

回答这个问题, 要了解**类加载的过程**和**构造器**.

1.**类加载的过程**  
当系统第一次使用某个类时, 会对该**类**进行**初始化(类加载)**。假设我们在类中定义了静态变量,

public static int value = 10;

**这行初始化语句在什么时候执行?** 类加载的初始化阶段.

类加载分为三步: **加载——> 连接 ——> 初始化.**  
在连接阶段, 系统会为静态变量分配空间并设定默认值.  
在初始化阶段, 才会执行静态变量的初始化语句.

我们在new一个对象时, 只有**首次使用该类才会对类变量的初始化**。再次new该类对象就不会对类变量初始化, 因为类已经存在。  
  
  
**2.构造器**  
构造器的作用——对成员变量初始化并返回对象引用.

**构造器完全负责对象的创建吗?**  
No.构造器是创建对象的途径, 但它并非完全负责对象创建。  
**当构造器被调用时, 系统会先为对象分配空间, 并对该对象进行默认初始化.** 这个默认初始化类似于上述的静态变量初始化, 系统设置默认值——>初始化语句(假如声明变量时指定了初始值).

**就是说, 在调用构造器之前, 对象已经产生了, 但是外部程序还不能访问它, 只能通过this引用.**