静态代码块 非静态代码块 构造函数 的执行顺序

最新推荐文章于 2025-05-13 15:17:18 发布
原创 最新推荐文章于 2025-05-13 15:17:18 发布 · 8.6k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一个Java程序中静态代码块、非静态代码块及构造方法的执行顺序。演示了如何通过不同的代码块来初始化类和实例变量，并展示了静态方法内的执行流程。 
public class Test {
    public Test() {
        System.out.print("默认构造方法！--");
    }

    //非静态代码块
    {
        System.out.print("非静态代码块！--");
    }

    //静态代码块
    static {
        System.out.print("静态代码块！--");
    }

    private static void test() {
        System.out.print("静态方法中的内容! --");
        {
            System.out.print("静态方法中的代码块！--");
        }

    }

    public static void main(String[] args) {
        Test test = new Test();
        Test.test();//静态代码块！--静态方法中的内容! --静态方法中的代码块！--
    }
}
静态代码块！--非静态代码块！--默认构造方法！--静态方法中的内容! --静态方法中的代码块！--
java静态代码块，构造方法，构造代码块的执行先后顺序
m0_58680865的博客
05-24 1万+
1、执行顺序 静态代码块>构造代码块>构造方法 原因： 静态代码块（static{}）在类加载的时候执行一次，是最早被执行的。 构造代码块（{}内的部分）在每一次创建对象时执行，始终在构造方法前执行。 构造方法在新建对象时调用（ 就是new的时候 ）。 注意： 静态代码块在类加载的时候就执行，所以它的优先级高于入口main()方法。 当三种形式不止一次出现，同优先级是按照先后顺序执行。 程序代码示例： public class StaticTest { public stati
java静态代码块和非静态代码块和构造函数执行顺序
cym19的博客
07-28 2714
是用来初始化类的实例信息，在创建对象的时候就会被执行，且每创建一个对象都会被执行一次。执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。程序在执行时，首先执行静态代码块，且只执行一次。父类静态代码块>子类静态代码块>父类非静态代码块>父类构造方法>子类非静态代码块>子类构造方法。是用来初始化类的信息，在类被加载的时候就会被执行，且只执行一次。静态代码块-->非静态代码块-->构造方法。...
Static静态代码块以及各代码块之间的执行顺序
热门推荐
宜春
10-16 2万+
前言 在Java中，Static静态代码块、构造代码块、普通代码块、构造函数的执行顺序是一个java学习者必须掌握的基础，本篇博客旨在让大家能清除了解它们之间的执行顺序。 文章目录代码块的分类1、静态代码块（也叫静态块、静态初始化块）2、构造代码块（也叫构造初始化块）3、代码块（又叫普通代码块、初始化块）执行顺序的代码测试继承中各代码块的执行顺序 代码块的分类 基本上代码块分为三种：Static静...
java静态代码块，非静态代码快，构造函数的执行顺序
秋楓的博客
06-11 503
我们直接通过实例进行测试，然后看测试结果。 父类：Person public class Person { { System.out.println("父类非静态代码块"); } static { System.out.println("父类静态代码块"); } public Person() { System.out.println("父类构造函数"); ...
Java静态代码块构造函数执行_Java静态代码块、代码块及构造函数执行顺序
weixin_39716264的博客
02-27 107
根据以下程序进行分析定义一个父类package sas.LearnJava;public class ExcuteOrderTest {{System.out.println("我是在父类开始的普通代码块！");}public ExcuteOrderTest() {System.out.println("我是父类的无参构造函数！");}public void showSomething() {Sy...
静态代码块、非静态代码块和构造函数的执行顺序
我的安卓之路
07-26 540
例子1： public class test1 { public static void main(String[] args) throws ClassNotFoundException { } public test1() { System.out.println("test1构造函数"); } static { System.out.println("test1静态代码块"); } {
Java中静态代码块，非静态代码块，构造函数的执行顺序
m0_37671741的博客
09-01 2739
静态代码块：是用来初始化类的信息，在类被加载的时候就会被执行，且只执行一次。执行优先级高于非静态的初始化块。 非静态代码块：是用来初始化类的实例信息，在创建对象的时候就会被执行，且每创建一个对象都会被执行一次。执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。 构造方法：是用来创建对象的。 执行顺序：静态代码块>非静态代码块>构造方法 即：程序在执行时，首先执行静态代码块，且只执行一次。接下来再创建对
静态代码块,非静态代码块,构造函数的执行顺序
ZhYa24的博客
09-18 164
父类静态代码块 ->子类静态代码块 ->父类非静态代码块 -> 父类构造函数 -> 子类非静态代码块 -> 子类构造函数 public class Father { static { System.out.println("父类静态代码块"); } { System.out.println("父类非静态代码块"); } public Father(){ System.out.pr.
java静态代码块执行次数_Java中构造函数、静态代码块、代码块的执行顺序
weixin_30818373的博客
03-01 271
先看一段代码：package com.wjj.test;/*** @author 作者 : 榨菜哥* @createTime 创建时间：2018年7月27日 下午3:26:47* @discription 类说明：* @version 版本：*/public class ConstructorTest {public static void main(String[]...
静态代码块、构造代码块以及构造函数的加载顺序
s_156的博客
09-29 170
介绍具体的例子 Parent类：   public class Parent { public Parent() { System.out.println("这是父类的构造方法"); } public void d_Parent() { System....
Java代码块执行顺序详解：静态代码块、构造代码块与构造方法
记录学习的过程
05-13 987
在Java中，静态代码块、构造代码块和构造方法的执行顺序是类初始化和对象实例化过程中的关键概念。静态代码块在类加载时执行，且只执行一次，用于初始化静态资源；构造代码块在每次创建对象时执行，且在构造方法之前，用于提取多个构造方法的公共逻辑；构造方法则用于初始化对象状态。执行顺序遵循“父类静态代码块 → 子类静态代码块 → 父类构造代码块 → 父类构造方法 → 子类构造代码块 → 子类构造方法”的规则。理解这些顺序有助于掌握Java对象的生命周期，并在实际开发中合理使用这些代码块进行资源初始化和对象管理。
java中静态代码块与构造方法的执行顺序判断
08-28
在Java编程语言中，了解静态代码块和构造方法的执行顺序是至关重要的，尤其是在处理类的初始化和对象的创建时。下面将详细解释这些概念及其执行逻辑。 首先，静态代码块（也称为静态初始化器）是由`static`关键字...
深入浅析Java中普通代码块、构造代码块与静态代码块
09-01
例如，在给定的示例中，静态代码块在程序启动时首先执行，然后是`main`方法，接着是构造代码块（每次创建对象时），最后是构造函数。如果类中还有其他类，如类`A`，那么`A`的静态代码块会在`structure`类的`main`...
!、&&、 ||、 ^、 &、 |
wiscourper的博客
11-25 8236
逻辑运算符 !：逻辑否定，取反 &&：逻辑与（有短路） ||：逻辑或（有短路） ^：异或，排同，相同则false,不同则true 无条件布尔运算符 |和||，&和&&在使用中几乎相同，只是&和|没有短路现象，也就是说他们的两个运算对象都要计算。 ...
java中super的用途
wiscourper的博客
11-27 3423
super可以用来引用直接父类的实例变量。 super可以用来调用直接父类方法。 super()可以用于调用直接父类构造函数。 public class Test { public static void main(String[] args) { Dog dog = new Dog(); dog.accessParentProperty(); dog.accessParentMethod(); } } class Animal {
ThreadPoolExecutor创建线程池
wiscourper的博客
11-12 1361
1、ThreadPoolExecutor构造函数重要参数分析 ThreadPoolExecutor3 个最重要的参数： corePoolSize:核心线程数线程数定义了最小可以同时运行的线程数量。 maximumPoolSize:当队列中存放的任务达到队列容量的时候，当前可以同时运行的线程数量变为最大线程数。 workQueue:当新任务来的时候会先判断当前运行的线程数量是否达到核心线程数，如果达到的话，新任务就会被存放在队列中。 ThreadPoolExecutor其他常见参数: k...
18、泛型
wiscourper的博客
11-15 1314
一、泛型的概念 >所谓泛型，就是允许在定义类、接口时通过一个标识表示类中某个属性的类型或者是某个方法的返回值及参数类型。这个类型参数将在使用时（例如，继承或实现这个接口，用这个类型声明变量、创建对象时）确定（即传入实际的类型参数，也称为类型实参）。 >从JDK1.5以后，Java引入了“参数化类型（Parameterized type）”的概念，允许我们在创建集合时再指定集合元素的类型，正如：List<String>，这表明该List只能保存字符串类型的对象。 &g
23、JDBC
wiscourper的博客
12-09 1261
一、jdbc概述 1.1Java中的数据存储技术 在Java中，数据库存取技术可分为如下几类： 1）JDBC直接访问数据库 2）JDO (Java Data Object )技术 3）第三方O/R工具，如Hibernate, Mybatis 等 JDBC是java访问数据库的基石，JDO、Hibernate、MyBatis等只是更好的封装了JDBC。 1.2JDBC介绍 JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用
子类A继承父类B,Aa=new A();则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块执行的先后顺序是？〇 A:父类B构造函数->父类B静态代码块->父类B非静态代码块->子类A静态代码块->子类A构造函数->子类A非静态代码块○ B:父类B静态代码块->父类B构造函数->子类A静态代码块->父类B非静态代码块->子类A构造函数->子类A非静态代码块○ C:父类B静态代码块->父类B构造函数->父类B非静态代码块->子类A静态代码块->子类A构造函数->子类A非静态代码块○ D:父类B静态代码块->子类A静态代码块->父类B非静态代码块->父类B构造函数->子类A非静态代码块->子类B构造函数
最新发布
09-24
<think> 首先，用户的问题是：子类A继承父类B，执行Aa=new A();时，父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块的执行顺序是什么？选项有A、B、C、D。 我需要回忆Java中的类加载和对象初始化顺序。关键点是： 1. 静态代码块（static initializer blocks）：在类加载时执行，只执行一次。 2. 非静态代码块（instance initializer blocks）：在对象创建时执行，每次创建对象时执行，在构造函数之前执行。 3. 构造函数：在对象创建时执行。 当一个类被加载时，其静态代码块会执行。当创建一个对象时，顺序是： - 父类的静态代码块（如果类还未加载） - 子类的静态代码块（如果类还未加载） - 然后，在对象实例化时： - 父类的非静态代码块 - 父类的构造函数 - 子类的非静态代码块 - 子类的构造函数 更精确的顺序是： - 类加载阶段（只发生一次）： - 先加载父类，执行父类的静态代码块。 - 然后加载子类，执行子类的静态代码块。 - 对象实例化阶段： - 分配内存空间。 - 初始化父类部分： - 执行父类的非静态代码块。 - 执行父类的构造函数。 - 然后初始化子类部分： - 执行子类的非静态代码块。 - 执行子类的构造函数。 在子类的构造函数中，如果没有显式调用父类构造函数，会隐式调用父类的无参构造函数（super()）。 具体到这个场景：Aa = new A(); - A 是子类，继承自 B。 - 当第一次加载类时，静态代码块会执行。 假设类B和A都还未加载。 顺序应该是： 1. 加载父类B： - 执行B的静态代码块。 2. 加载子类A： - 执行A的静态代码块。 3. 然后，创建A的实例： - 执行B的非静态代码块（因为A继承自B）。 - 执行B的构造函数。 - 然后执行A的非静态代码块。 - 最后执行A的构造函数。 在Java中，非静态代码块在构造函数之前执行，但在super()调用之后。 更详细： - 当调用new A()时： - 首先，如果类A未加载，加载类A。加载A时，需要加载其父类B（如果未加载）。 - 所以： - 加载B：执行B的静态代码块。 - 加载A：执行A的静态代码块。 - 然后，实例化A： - 调用A的构造函数（隐式或显式super()）。 - 在super()中，执行B的初始化： - 执行B的非静态代码块。 - 执行B的构造函数体。 - 然后返回到A的构造函数： - 执行A的非静态代码块。 - 执行A的构造函数体。 所以，完整顺序： 1. B的静态代码块（在类加载时） 2. A的静态代码块（在类加载时） 3. B的非静态代码块（在对象创建时） 4. B的构造函数 5. A的非静态代码块 6. A的构造函数 现在，看选项： ○ A:父类B构造函数->父类B静态代码块->父类B非静态代码块->子类A静态代码块->子类A构造函数->子类A非静态代码块 这错了，静态代码块应该在构造函数之前执行。 ○ B:父类B静态代码块->父类B构造函数->子类A静态代码块->父类B非静态代码块->子类A构造函数->子类A非静态代码块 这里有顺序问题：先B静态代码块，然后B构造函数，然后A静态代码块——但静态代码块应该在类加载时执行，所以A静态代码块应该在B静态代码块之后立即执行，而不是在B构造函数之后。而且在构造函数之后才执行非静态代码块，不对。 ○ C:父类B静态代码块->父类B构造函数->父类B非静态代码块->子类A静态代码块->子类A构造函数->子类A非静态代码块 顺序混乱：B静态代码块后是B构造函数，但非静态代码块应该在构造函数之前执行。而且A静态代码块应该在更早执行。 ○ D:父类B静态代码块->子类A静态代码块->父类B非静态代码块->父类B构造函数->子类A非静态代码块->子类A构造函数 这看起来很接近：B静态代码块 -> A静态代码块 -> B非静态代码块 -> B构造函数 -> A非静态代码块 -> A构造函数。 在D中，它写的是“子类B构造函数”，可能是笔误，应该是“子类A构造函数”，因为选项中是“子类A构造函数”。 在用户消息中：○ D:父类B静态代码块->子类A静态代码块->父类B非静态代码块->父类B构造函数->子类A非静态代码块->子类B构造函数 应该是“子类A构造函数”，不是“子类B”。可能是个打字错误。 所以，D的顺序是： - 父类B静态代码块 - 子类A静态代码块 - 父类B非静态代码块 - 父类B构造函数 - 子类A非静态代码块 - 子类A构造函数（或子类B，但应该是A） 这符合Java的顺序。 验证： - 静态代码块：父类先加载和执行静态块，然后子类加载和执行静态块。 - 实例化：父类非静态代码块 -> 父类构造函数 -> 子类非静态代码块 -> 子类构造函数。 是的。 在Java中，非静态代码块在构造函数之前执行。例如： ```java class Parent { static { System.out.println("Parent static block"); } { System.out.println("Parent instance block"); } Parent() { System.out.println("Parent constructor"); } } class Child extends Parent { static { System.out.println("Child static block"); } { System.out.println("Child instance block"); } Child() { System.out.println("Child constructor"); } } public class Main { public static void main(String[] args) { Child c = new Child(); } } ``` 输出： Parent static block Child static block Parent instance block Parent constructor Child instance block Child constructor 所以顺序是： 1. B static block 2. A static block 3. B non-static block 4. B constructor 5. A non-static block 6. A constructor 现在回到选项D：它匹配：父类B静态代码块->子类A静态代码块->父类B非静态代码块->父类B构造函数->子类A非静态代码块->子类A构造函数 虽然在选项中写的是“子类B构造函数”，但上下文是子类A，所以应该是A。 其他选项都不匹配。 例如，C有顺序不对。 所以正确答案应该是D。 在我的回答中，我需要先回答问题，然后提出3-5个相关问题。 回答格式： - 先用中文回答问题。 - 解释顺序。 - 然后输出“§§相关问题§§”，并在同一行或紧接着列出3-5个问题。 在示例中，是“§§相关问题§§”然后换行列问题列表，但指令说“禁止换行分散”，意思是“§§相关问题§§”必须在一行，然后问题列表可以换行，但“§§相关问题§§”本身不能分散。 看示例： 在代码块后，是“§§相关问题§§”然后换行，1. ... 2. ... 3. ... 指令说：“第一行必须完整且输出 \"§§相关问题§§\"！禁止换行分散。” 意思是最少“§§相关问题§§”必须在一行输出，不能换行输出部分文本。 在示例中，它是完整的“§§相关问题§§”然后换行列问题。 所以我认为： - 回答问题内容。 - 然后输出一行“§§相关问题§§” - 然后在下面列出3-5个问题，数字点。 相关问题应该基于用户的问题和我的回答。 用户问题是关于Java类初始化顺序的。 所以相关问题可以是： 1. 如果父类没有无参构造函数，子类该如何处理？ 2. 静态代码块在哪些情况下会被执行？ 3. 非静态代码块和构造函数的区别是什么？ 4. 在多重继承（接口或类）中，初始化顺序如何？ 5. 类加载器如何影响静态代码块的执行？ 等等。 我需要3-5个。 现在，写回答。 首先，确认答案：选项D是正确的。 顺序是：B静态代码块 -> A静态代码块 -> B非静态代码块 -> B构造函数 -> A非静态代码块 -> A构造函数。 在D中，写的是“子类B构造函数”，但应该是“子类A构造函数”，我会在回答中澄清。 回答结构： 1. 解释正确顺序。 2. 指出正确选项。 3. 然后输出“§§相关问题§§”和问题列表。 用中文。 </think> 在执行 `Aa = new A();` 时，Java 类初始化和对象实例化的顺序遵循特定规则，包括静态代码块（在类加载时执行一次）、非静态代码块（在对象创建时执行，在构造函数前）和构造函数。正确顺序为： 1. 父类 B 的静态代码块（类加载时优先执行）。 2. 子类 A 的静态代码块（类加载时执行）。 3. 父类 B 的非静态代码块（对象实例化时，父类部分初始化）。 4. 父类 B 的构造函数（对象实例化时执行）。 5. 子类 A 的非静态代码块（对象实例化时，子类部分初始化）。 6. 子类 A 的构造函数（对象实例化时最后执行）。 对比选项： - **A** 错误（静态代码块应在构造函数前执行）。 - **B** 错误（子类 A 的静态代码块应在父类 B 构造函数前执行）。 - **C** 错误（父类 B 的非静态代码块应在其构造函数前执行，且子类 A 的静态代码块应在更早执行）。 - **D** 正确（但选项中的“子类B构造函数”应为“子类A构造函数”，可能是笔误）。 因此，正确答案是 **D**。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值