文章详情

短信预约-IT技能 免费直播动态提醒

请输入下面的图形验证码

提交验证

短信预约提醒成功

一文搞懂java中类及static关键字执行顺序

2024-04-02 19:55

关注

类的生命周期

静态变量的初始化有两种途径: (1)在静态变量的声明处进行初始化 (2)在静态代码块中进行初始化

使用:使用这个类;卸载:

接着我们来了解static关键字的作用和使用条件

static关键字

static关键字修饰的数据存储在我们的方法区中的静态常量池中,static可以修饰方法、变量和代码块

static修饰方法:指定不需要实例化就可以激活的一个方法。this关键字不能再static方法中使用静态方法中不能使用非静态方法非静态方法可以调用静态方法。

static修饰变量:指定变量被所有对象共享,即所有实例都可以使用该变量。变量属于这个类。

static修饰代码块:无论放在哪里,都是放在main方法运行的。通常用于初始化静态变量,静态代码块属于类。不可以省略,没加static认为是构造代码块

static关键字执行顺序

先记住几个准则;

我们来通过一个例子来验证以下上面的观点

InitializeDemo.java

package com.qcby.demo.staticDemo;


public class InitializeDemo {
    private static int k = 1;
    private static InitializeDemo t1 = new InitializeDemo("t1");
    private static InitializeDemo t2 = new InitializeDemo("t2");
    private static int i = print("i");
    private static int n = 99;

    {
        print("初始化块");
        j=100;
    }
    public InitializeDemo(String str) {
        System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;

    }
    static {
        print("静态块");
        n=100;
    }
    private int j = print("j");
    public static int print(String str) {
        System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
        ++n;
        return ++i;
    }
    public static void main(String[] args) {
        InitializeDemo test = new InitializeDemo("test");
    }
}

输出结果:

我们来逐个分析,

一开始调用main方法,main方法内实例化InitializeDemo的对象,在对象载入之前,一定要是类先被载入

所以我们先加载InitializeDemo类,加载类的同时,会加载静态变量和静态代码块,但是是按顺序执行,且只执行一次

先加载如下静态变量

private static int k = 1;

加载如下静态变量的时候,发现要去加载类,由于类以及加载了,所以会加载这个对象,这个对象加载前,会执行非静态代码块

private static InitializeDemo t1 = new InitializeDemo("t1");

此时也就是

1:初始化块 i=0 n=0

接着执行

private int j = print("j");

2:j i=1 n=1

接着执行构造方法,

public InitializeDemo(String str) {
        System.out.println((k++) + ":" + str + "   i=" + i + "    n=" + n);
        ++i;
        ++n;

    }

3:t1 i=2 n=2

t1的实例化执行结束,接着执行t2的实例化

private static InitializeDemo t2 = new InitializeDemo("t2");

结果和上述一致,按非静态代码块和非静态属性然后构造方法方法的顺序执行

4:初始化块 i=3 n=3

5:j i=4 n=4

6:t2 i=5 n=5

两个静态属性(实例化)执行完,执行如下代码

private static int i = print("i");

7:i i=6 n=6

接着执行下面的代码,此时n变成了99

private static int n = 99;

接着执行静态代码块

static {
        print("静态块");
        n=100;
    }

8:静态块 i=7 n=99

类加载完毕,执行test对象的载入,参考t1,t2的实例化,按非静态代码块和非静态属性然后构造方法方法的顺序执行

9:初始化块 i=8 n=100

10:j i=9 n=101

11:test i=10 n=102

继承中的static执行顺序

例子一:

package com.qcby.demo.oop;

public class Test3 extends Base {
    static {
        System.out.println("test static");
    }
    public Test3(){
        System.out.println("test constructor");
    }

    public static void main(String[] args) {
        new Test3();
    }
}
class Base{
    static {
        System.out.println("Base static");
    }
    public Base(){
        System.out.println("Base constructor");
    }
}

执行Test3的构造方法,要先加载Test3的类加载,由于Test3继承于Base,所以他要先加载父类Base,

所以先Base static 后test static 在执行子类的构造方法的时候,要先执行父类的构造方法,如果是多级继承,会先执行最顶级父类的构造方法,然后依次执行各级个子类的构造方法。 所以先执行Base constructor后执行test constructor结果就如上图

例子二(重点)

package com.qcby.demo.oop;

public class MyTest {
    MyPerson person = new MyPerson("test");//这里可以理解为成员变量辅助,,要先把MyPerson先加载到jvm中
    static {
        System.out.println("test static");//1
    }

    public MyTest() {
        System.out.println("test constructor");//5
    }

    public static void main(String[] args) {//main方法在MyTest类中,使用mian方法先加载MyTest的静态方法,不调用其他,
        MyClass myClass =new MyClass();//对象创建的时候,会加载对应的成员变量
    }
}
class MyPerson {
    static {
        System.out.println("person static");//3
    }

    public MyPerson(String str) {
        System.out.println("person " + str);//4  6
    }
}
class MyClass extends MyTest {
    MyPerson person = new MyPerson("class");//这里可以理解为成员变量辅助,要先把MyPerson先加载到jvm中
    static {
        System.out.println("class static");//2
    }
    
    public MyClass() {
        //默认super()
        System.out.println("class constructor");//7
    }
}

1.先看main方法,main方法回先加载对应的类,此时MyTest类和其静态的变量,方法和代码块会随类的加载而开辟空间。static是属于类的。所以test static优先执行,且此时MyTest类的其他语句不执行。

2.mian方法中调用了MyClass myClass =new MyClass(),实例化了一个MyClass类的对象,这时候会初始化对象的成员变量和调用对象的构造函数,而MyClass类继承于MyTest类,在加载MyClass类前,会先调用MyTest类,但是MyTest类以及其静态的变量,方法和代码块已经加载(在类的生命周期只执行一次),所以返回到子类(MyClass类)的加载,这时候会调用MyClass类的静态的变量,方法和代码块。所以class static第二个执行。

3.MyClass类加载完后,应该接着调用MyClass类的构造方法,在调用子类的构造方法前,会默认调用父类的无参构造方法(super()省略),调用父类的无参构造方法,相当于实例化父类的对象,这时候会先初始化对象的成员变量,这里的MyPerson person = new MyPerson(“test”);就相当于成员变量(属于对象,在对象的实例化的时候才加载),于是会加载MyPerson类和其静态的变量,方法和代码块。所以person static第三个执行

4.加载完MyPerson类和其静态的变量,方法和代码块后,会调用MyPerson类和的有参构造方法,即person test第四个执行

5.MyPerson类和的有参构造方法执行结束,返回父类MyTest,父类调用构造方法,即test constructor第五个执行

6.父类MyTest构造方法执行结束,返回子类,子类再调用构造方法前,先初始化对象的成员变量MyPerson person = new MyPerson(“class”);,这时候会先先加载MyPerson 和其静态的变量,方法和代码块。由于上述类以及加载,所以直接执行其有参构造方法,即person class第六个执行

7.MyPerson类和的有参构造方法执行结束,返回子类MyClass,子类调用构造方法,即class constructor第七个执行

父类static代码块–>子类static代码块–>父类普通代码块(成员对象属性初始化)–>父类构造方法–>子类普通代码块(成员对象属性初始化–>子类构造方法

总结

类加载顺序的三个原则是

类加载顺序为(默认变量卸载代码块前)

父类静态变量->父类静态语句块->子类静态变量->子类静态语句块->父类普通成员变量->父类动态语句块->父类构造器->子类普通成员变量->子类动态语句块->子类构造器

到此这篇关于一文搞懂java中类及static关键字执行顺序的文章就介绍到这了,更多相关java static关键字执行顺序内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网!

阅读原文内容投诉

免责声明:

① 本站未注明“稿件来源”的信息均来自网络整理。其文字、图片和音视频稿件的所属权归原作者所有。本站收集整理出于非商业性的教育和科研之目的,并不意味着本站赞同其观点或证实其内容的真实性。仅作为临时的测试数据,供内部测试之用。本站并未授权任何人以任何方式主动获取本站任何信息。

② 本站未注明“稿件来源”的临时测试数据将在测试完成后最终做删除处理。有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

软考中级精品资料免费领

  • 历年真题答案解析
  • 备考技巧名师总结
  • 高频考点精准押题
  • 2024年上半年信息系统项目管理师第二批次真题及答案解析(完整版)

    难度     813人已做
    查看
  • 【考后总结】2024年5月26日信息系统项目管理师第2批次考情分析

    难度     354人已做
    查看
  • 【考后总结】2024年5月25日信息系统项目管理师第1批次考情分析

    难度     318人已做
    查看
  • 2024年上半年软考高项第一、二批次真题考点汇总(完整版)

    难度     435人已做
    查看
  • 2024年上半年系统架构设计师考试综合知识真题

    难度     224人已做
    查看

相关文章

发现更多好内容

猜你喜欢

AI推送时光机
位置:首页-资讯-后端开发
咦!没有更多了?去看看其它编程学习网 内容吧
首页课程
资料下载
问答资讯