Java（静态）变量、（静态）代码块、构造方法的执行顺序

最新推荐文章于 2024-07-08 15:08:45 发布
最新推荐文章于 2024-07-08 15:08:45 发布
阅读量473 收藏 1
点赞数
文章标签： java
原文链接：http://www.cnblogs.com/hglibin/p/9996816.html
版权

Java（静态）变量、（静态）代码块、构造方法的执行顺序

总结 1、父类静态变量和静态代码块（先声明的先执行）; 2、子类静态变量和静态代码块（先声明的先执行）; 3、父类的变量和代码块（先声明的先执行）; 4、父类的构造方法; 5、子类的变量和代码块（先声明的先执行）; 6、子类的构造方法。 注意事项 1、非静态代码块于构造方法之前执行,并且 每次实例化对象之前都会先执行非静态代码块,静态代码块于非静态代码块之前执行; 2、在类第一次被调用时,加载该类, 静态代码块只执行一次; 3、静态代码块只能调用静态变量,静态方法只能调用静态变量; 4、非静态代码块或非静态方法可以调用任何(静态+非静态)变量; 5、非静态代码块在实例化对象时,于构造方法之前执行。

参考代码 1

class HelloA {
    public HelloA() {
        System.out.println("HelloA");
    }

    {
        System.out.println("I'm A class");
    }

    static {
        System.out.println("static A");
    }
}

public class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }

    {
        System.out.println("I'm B class");
    }

    static {
        System.out.println("static B");
    }

    public static void main(String[] args) {
        new HelloB();
    }
}

运行结果

static A
static B
I'm A class
HelloA
I'm B class
HelloB

参考代码 2

class A {
    public A() {
        System.out.println("HelloA");
    }

    {
        System.out.println("I'm A class");
    }

    static {
        System.out.println("static A");
    }
}

public class B extends A {
    public B() {
        System.out.println("HelloB");
    }

    {
        System.out.println("I'm B class");
    }

    static {
        System.out.println("static B");
    }

    public static void main(String[] args) {
        new B();
    }
}

运行结果

static A
static B
I'm A class
HelloA
I'm B class
HelloB

参考代码 3

class A {
    static {
        System.out.print("1");
    }

    public A() {
        System.out.print("2");
    }
}

class B extends A {
    static {
        System.out.print("a");
    }

    public B() {
        System.out.print("b");
    }
}

public class Hello {
    public static void main(String[] args) {
        new B();
        new B();
    }
}

运行结果

1a2b2b

参考代码 4

public class HelloA {
    static {
        System.out.println("static A");
    }

    {
        System.out.println("I'm A class");
    }

    public HelloA() {
        System.out.println("HelloA");
    }

    public HelloA(String s) {
        System.out.println(s + "HelloA");
    }

    public static void main(String[] args) {
        new HelloB();
    }
}

class HelloB extends HelloA {
    public HelloB() {
        // 只能调用一次父类的构造方法，如果不写，Java 编译器会自动调用无参的构造方法。
        // super();
        super("parent");
        System.out.println("HelloB");
    }

    {
        System.out.println("I'm B class");
    }

    static {
        System.out.println("static B");
    }
}

运行结果

static A
static B
I'm A class
parentHelloA
I'm B class
HelloB

参考代码 5

public class People {
    String name;

    public People() {
        System.out.println(1);
    }

    public People(String name) {
        System.out.println(2);
        this.name = name;
    }
}

class Child extends People {
    People father;

    public Child() {
        // super(); // 系统默认调用父类的无参构造方法
        System.out.println(4);
    }

    public Child(String name) {
        // super(); // 系统默认调用父类的无参构造方法
        System.out.println(3);
        this.name = name;
        father = new People(name + ":F");
        System.out.println(father.name);
    }

    public static void main(String[] args) {
        new Child();
        // new Child("mike");
    }
}

运行结果

1
4

参考代码 6

public class People {
    String name;

    public People() {
        System.out.println(1);
    }

    public People(String name) {
        System.out.println(2);
        this.name = name;
    }
}

class Child extends People {
    People father;

    public Child() {
        // super(); // 系统默认调用父类的无参构造方法
        System.out.println(4);
    }

    public Child(String name) {
        // super(); // 系统默认调用父类的无参构造方法
        System.out.println(3);
        this.name = name;
        father = new People(name + ":F");
        System.out.println(father.name);
    }

    public static void main(String[] args) {
        // new Child();
        new Child("mike");
    }
}

运行结果

1
3
2
mike:F

参考代码 7

public class ExA {
    private static ExA a = new ExA();

    static {
        System.out.println("父类---静态代码块");
    }

    public ExA() {
        System.out.println("父类---构造方法");
    }

    {
        System.out.println("父类---非静态代码块");
    }

    public static void main(String[] args) {
        new ExB();
    }
}

class ExB extends ExA {
    private static ExB b = new ExB();

    static {
        System.out.println("子类---静态代码块");
    }

    {
        System.out.println("子类---非静态代码块");
    }

    public ExB() {
        System.out.println("子类---构造方法");
    }
}

运行结果

父类---非静态代码块
父类---构造方法
父类---静态代码块
父类---非静态代码块
父类---构造方法
子类---非静态代码块
子类---构造方法
子类---静态代码块
父类---非静态代码块
父类---构造方法
子类---非静态代码块
子类---构造方法

参考代码 8

class Foo {
    public Foo(String word) {
        System.out.println(word);
    }
}

class Parent {
    static Foo FOO = new Foo("Parent's static parameter");

    Foo foo = new Foo("Parent's parameter");

    static {
        System.out.println("Parent's static code block");
    }

    {
        System.out.println("Parent's code block");
    }

    public Parent() {
        System.out.println("Parent.Parent()");
    }
}

public class Child extends Parent {
    static Foo FOO = new Foo("Child's static parameter");

    Foo foo = new Foo("Child's parameter");

    static {
        System.out.println("Child's static code block");
    }

    {
        System.out.println("Child's code block");
    }

    public Child() {
        System.out.println("Child.Child()");
    }

    public static void main(String[] args) {
        new Child();
    }
}

运行结果

Parent's static parameter
Parent's static code block
Child's static parameter
Child's static code block
Parent's parameter
Parent's code block
Parent.Parent()
Child's parameter
Child's code block
Child.Child()

参考代码 9

public class GFG {
    public GFG(int x) {
        System.out.println("ONE argument constructor");
    }

    public GFG() {
        System.out.println("No argument constructor");
    }

    static {
        System.out.println("1st static init");
    }

    {
        System.out.println("1st instance init");
    }

    {
        System.out.println("2nd instance init");
    }

    static {
        System.out.println("2nd static init");
    }

    public static void main(String[] args) {
        new GFG();
        new GFG(8);
    }
}

运行结果

1st static init
2nd static init
1st instance init
2nd instance init
No argument constructor
1st instance init
2nd instance init
ONE argument constructor

参考代码 10

class MyTest {
    static {
        initialize();
    }

    private static int sum;

    public static int getSum() {
        initialize();
        return sum;
    }

    private static boolean initialized = false;

    private static void initialize() {
        if (!initialized) {
            for (int i = 0; i < 100; i++)
                sum += i;
            initialized = true;
        }
    }
}

public class GFG {
    public static void main(String[] args) {
        System.out.println(MyTest.getSum());
    }
}

运行结果

9900

参考代码 11

class MyTest {
    static {
        initialize();
    }

    private static int sum = 0;

    public static int getSum() {
        initialize();
        return sum;
    }

    private static boolean initialized = false;

    private static void initialize() {
        if (!initialized) {
            for (int i = 0; i < 100; i++)
                sum += i;
            initialized = true;
        }
    }
}

public class GFG {
    public static void main(String[] args) {
        System.out.println(MyTest.getSum());
    }
}

运行结果

4950

参考代码 12

class MyTest {
    static {
        initialize();
    }

    private static int sum = 0;

    public static int getSum() {
        initialize();
        return sum;
    }

    private static boolean initialized;

    private static void initialize() {
        if (!initialized) {
            for (int i = 0; i < 100; i++)
                sum += i;
            initialized = true;
        }
    }
}

public class GFG {
    public static void main(String[] args) {
        System.out.println(MyTest.getSum());
    }
}

运行结果

0

参考代码 13

class MyTest {
    static {
        initialize();
    }

    private static int sum;

    public static int getSum() {
        initialize();
        return sum;
    }

    private static boolean initialized;

    private static void initialize() {
        if (!initialized) {
            for (int i = 0; i < 100; i++)
                sum += i;
            initialized = true;
        }
    }
}

public class GFG {
    public static void main(String[] args) {
        System.out.println(MyTest.getSum());
    }
}

运行结果

4950

10-13 题解析

参考资料

转载于:https://www.cnblogs.com/hglibin/p/9996816.html

weixin_30823683
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
面试题--JAVA中静态块、静态变量加载顺序详解
上善若水，厚德载物
06-03 1万+
public class test { //1.第一步，准备加载类 public static void main(String[] args) { new test(); //4.第四步，new一个类，但在new之前要处理匿名代码块 } static
Java静态代码块作用及执行顺序解析
08-19
在继承关系中，静态代码块的执行顺序是：父类静态代码块 -> 子类静态代码块 -> 父类非静态代码块 -> 父类构造方法 -> 子类非静态代码块 -> 子类构造方法。 静态代码块和静态方法的区别在于：静态代码块是自动执行的...
Java静态变量和构造函数的执行顺序（实例二）
yangjianli868的专栏
09-07 161
package com.devin;public class MyMain { public static void main(String args[]) { Father f = new Son(); }}class Father { public Father() { System.out.println("Father Construct");...
Java 静态变量、静态代码块、普通代码块、构造方法的执行顺序
最新发布
qq_63462564的博客
07-08 460
Java 静态变量、静态代码块、普通代码块、构造方法的执行顺序。6、执行的构造器是无参还是有参呢：因为java会自动给类装配一个无参构造器，所以在没有特殊定义的情况下会调用无参构造器。如自己去定义了一个有参构造器并且初始化的时候构造函数调用的是有参的，那它就会去执行有参的。这是我自己绘制的图，按从上到下，从左到右的顺序执行。2、因为静态变量和静态代码块是属于类的，所以在类加载的时候就会执行，且只会执行一次。4、普通代码块和构造函数是属于实例对象的，所以每次初始化一次就会执行一次。
java之静态变量，静态代码块及构造方法的执行顺序
m0_47325366的博客
07-17 781
java之静态变量，静态代码块及构造方法的执行顺序 1.我们来运行如下代码： package day11; import com.sun.scenario.effect.impl.sw.sse.SSEBlend_SRC_OUTPeer; public class try2 { public static void main(String[] args) { new Child(); } } //此类只实现一个打印的作用 class Print{ public P
java构造函数和静态变量的执行顺序（实例一）
yangjianli868的专栏
09-07 195
Java初始化顺序1在new B一个实例时首先要进行类的装载。（类只有在使用New调用创建的时候才会被java类装载器装入）；2，在装载类时，先装载父类A，再装载子类B3，装载父类A后，完成静态动作（包括静态代码和变量，它们的级别是相同的，安装代码中出现的顺序初始化）4，装载子类B后，完成静态动作。类装载完成，开始进行实例化1，在实例化子类B时，先要实例化父类A2，实例化父类A时，先成员实例化（非...
java静态变量、代码块、和静态方法的执行顺序是什么？
weixin_45712075的博客
08-29 405
基本上代码块分为三种：Static静态代码块、构造代码块、普通代码块 代码块执行顺序静态代码块——> 构造代码块 ——> 构造函数——> 普通代码块  继承中代码块执行顺序：父类静态块——>子类静态块——>父类代码块——>父类构造器——>子类代码块——>子类构造器 ...
java中静态代码块与构造方法的执行顺序判断
08-28
在Java编程语言中，了解静态代码块和构造方法的执行顺序是至关重要的，尤其是在处理类的初始化和对象的创建时。下面将详细解释这些概念及其执行逻辑。 首先，静态代码块（也称为静态初始化器）是由`static`关键字...
Java 普通代码块静态代码块执行顺序(实例讲解)
08-29
这里我们将深入探讨Java中的普通代码块（实例初始化块）和静态代码块的执行顺序，并通过实例来阐述这一概念。 首先，我们需要明白两种类型的代码块： 1. 静态代码块（Static Block）：这些代码块在类加载时执行，...
java中的静态代码块、构造代码块、构造方法详解
09-02
在Java编程语言中，类的初始化过程涉及到几个关键的概念，包括静态代码块、构造代码块和构造方法。这些概念在创建对象和管理类的状态时起着至关重要的作用。以下是关于这三个概念的详细解释： 1. **静态代码块**： ...
java 代码块与静态代码块加载顺序
08-29
Java 代码块是指在类中使用大括号 `{}` 包围的代码块，这些代码块可以出现在类的任何位置，包括构造函数、静态代码块、实例代码块等。Java 代码块的执行顺序取决于其所在的位置和上下文环境。 在上面的实例代码中，...
静态代码块、构造方法、构造代码块、变量、静态变量的执行顺序详解
xue_yun_xiang的博客
03-09 1464
一、语法格式 static { } 类文件只要加载，静态代码块就一定加载。 二、示例 public class DemoTest{ //静态代码块 //对对象加上静态修饰 static DemoTest demo1 = new DemoTest(); static DemoTest demo2 = new DemoTest(); //构造代码块 { System.out.println("这是构造代码块"); } st
java静态代码块、静态变量的执行顺序
欢迎来到【战羽】的博客
10-08 718
一般顺序：静态块（静态变量）——&amp;gt;成员变量——&amp;gt;构造方法——&amp;gt;静态方法 1、静态代码块（只加载一次） 2、构造方法（创建一个实例就加载一次） 3、静态方法需要调用才会执行 Demo1： public class Test { //1.第一步，准备加载类 public static void main(String[] ar...
JAVA中静态块、静态变量加载顺序详解
鲨鱼辣椒灬的博客
08-22 1306
一般顺序：静态块（静态变量）——>成员变量——>构造方法——>静态方法 1、静态代码块（只加载一次） 2、构造方法（创建一个实例就加载一次）3、静态方法需要调用才会执行，所以最后结果没有e 输出结果表明，程序的执行顺序为： 如果类还没有被加载： 1、先执行父类的静态代码块和静态变量初始化，并且静态代码块和静态变量的执行顺序只跟代码中出现的顺序有关。 2、执行子类的静...
java 中的静态变量，静态代码块，动态代码块，构造方法执行顺序的深入探究
weixin_38071106的博客
03-28 1056
原文：https://blog.csdn.net/qq_41063182/article/details/81149798 类加载：第一次调用这个类的时候jvm虚拟机会通过类加载器在一个叫做方法区的逻辑内存中将所要用到的类的信息存放在里边，其中方法区有一个静态区，存放的是类中的静态（类变量）。 对象构造：在堆中开辟一个内存空间将实例化的对象存放在里边，在生命周期中要远远小于类。 静态代码块只...
java静态变量，代码块，和静态方法的执行顺序
weixin_41828221的博客
03-31 360
类中声明的顺序进行初始化。
java类加载 静态变量和构造方法加载顺序
松鼠教授的博客
04-01 3362
demo1 /** * java规定，变量没有初始化不能使用，全局变量也就是类的属性，java会在编译的时候，自动将他们初始化， * 所以可以不进行变量初始化的操作，☆☆☆☆☆但是（局部）变量必须初始化☆☆☆☆☆ * * 静态数据的初始化 * 初始化的顺序是：先静态对象，而后是“非静态”对象。 * * 非静态成员初始化 * 在一个类中，非静态成员的初始化，发生在任何方法（包括构造方法）被调用之前。并且它们定义的顺序，决定了初始化的顺序 * 变量初始化完成之后才厚调用构造函数 * .
Java中静态变量、静态代码块的执行顺序
wushijuewu
09-16 248
Java中静态变量、静态代码块的执行顺序 首先创建3个类： 1、Out类，用于打印变量 public class Out { public Out(String word) { System.out.println(word); } } 2、Parent类 public class Parent { static Foo FOO = new Foo("Parent's static parameter"); Foo...
java静态变量、代码块、和静态方法的执行顺序是什 么？
08-30
总结起来，静态变量、静态代码块和静态方法的执行顺序是先父类的静态变量和静态代码块，再子类的静态变量和静态代码块，然后父类的实例变量和非静态代码块，接着是父类的构造方法，然后子类的实例变量和非静态代码块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值