资讯专栏INFORMATION COLUMN

Java代码执行顺序

hosition / 2593人阅读

摘要:没有关键字修饰的如实例变量非静态变量非静态代码块初始化实际上是会被提取到类的构造器中被执行的,但是会比类构造器中的代码块优先执行到,非静态实例变量非静态代码块的地位是相等的,它们将按顺序被执行。

阅读原文:Java代码执行顺序

程序中代码执行的顺序非常重要,稍有不慎便会是程序运行出错,那么我将结合实例来分析代码中的执行。

名词解释

首先了解几个名词:

非静态代码块
直接由 { } 包起来的代码,称为非静态代码块
静态代码块
直接由 static { } 包起来的代码,称为静态代码块
形参

比如你定义一个函数void add(int a, int b),这里的a和b就是形参。
当你进行函数调用的时候,add(1, 2),这里的1和2就是实参。

向前引用

所谓向前引用,就是在定义类、接口、方法、变量之前使用它们。

成员变量
在类体里面定义的变量称为成员变量;
如果该成员变量有 static 关键字修饰,则该成员变量称为 静态变量 或 类变量;
如果该成员变量没有 static 关键字修饰,则该成员变量被称为 非静态变量 或 实例变量。
局部变量
形参、方法内定义的变量、代码块中定义的变量,都属于局部变量。
类变量 (静态变量)
可以向前引用
变量属于类本身
类变量不依赖类的实例,类变量只在初始化时候在方法区中被分配一次空间,无论类的实例被创建几次,都不再为类变量分配空间
通过类的任意一个实例来访问类变量,底层都将将其转为通过类本身来访问类变量,它们的效果是一样的
一旦类变量的值被改变,通过类或类的任意一个实例来访问类变量,得到的都将是被改变后的值
将在类的初始化之前初始化
实例变量(非静态变量)
不能向前引用,如果向前引用,则称为非法向前引用,这是不允许的
变量属于类的实例对象
随着类的实例被创建而分配内存空间

实例演示
public class Parent {
    public int parentNum=0;
    public static int staticParentNum=0;
    
    {
        System.out.println("Parent---执行非静态代码块了1!");
    }
    
    {
        System.out.println("Parent---执行非静态代码块了2!");
    }
    
    static{
        System.out.println("Parent---执行静态代码块了1!");
    }
    
    static{
        System.out.println("Parent---执行静态代码块了2!");
    }

    public Parent(){
        System.out.println("Parent---无参构造函数!");
    }
    public Parent(int parentNum){
        this.parentNum=parentNum;
        System.out.println("Parent---有参构造函数!");
        
    }

    public void ParentMethod(int parentNum){
        this.parentNum=parentNum;
        System.out.println("Parent---非静态方法/parentNum="+parentNum);
    }
    
    public static void staticParentMethod(int staticParentNum){
        Parent.staticParentNum=staticParentNum;
        System.out.println("Parent---静态方法/staticParentNum="+staticParentNum);
    }
    
}
public class Child extends Parent{

    public int childNum=0;
    public static int staticChildNum=0;
    
    {
        System.out.println("Child---执行非静态代码块了1!");
    }
    
    {
        System.out.println("Child---执行非静态代码块了2!");
    }
    
    static{
        System.out.println("Child---执行静态代码块了1!");
    }
    
    static{
        System.out.println("Child---执行静态代码块了2!");
    }

    public Child(){
        super();
        System.out.println("Child---无参构造函数!");
    }
    
    public Child(int childNum){
        super(childNum);
        System.out.println("Child---有参构造函数!");
    }
    
    public void childMethod(int childNum){
        this.childNum=childNum;
        System.out.println("Child--非静态方法/childNum="+childNum);
    }
    
    public static void staticChildMethod(int staticChildNum){
        Child.staticChildNum=staticChildNum;
        System.out.println("Child---静态方法/staticChildNum="+staticChildNum);
    }

    
}
package test;

public class Test {

//    static{
//        System.out.println("Test---静态代码块!");
//    }
    public static void main(String[] args) {
        int key=10;
        switch (key) {
        case 0:
            Parent parent=new Parent();
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            Parent---执行非静态代码块了1!
//            Parent---执行非静态代码块了2!
//            Parent---无参构造函数!
//          说明:先加载静态代码块,后加载非静态代码块
        case 1:
            Child b= new Child();
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            Child---执行静态代码块了1!
//            Child---执行静态代码块了2!
//            Parent---执行非静态代码块了1!
//            Parent---执行非静态代码块了2!
//            Parent---无参构造函数!
//            Child---执行非静态代码块了1!
//            Child---执行非静态代码块了2!
//            Child---无参构造函数!
//            说明:创建子类,会先执行父类,先执行父类静态——>子类静态——>父类非静态——>父类构造
//——>子类非静态——>子类构造
        case 2:
            Child c= new Child(4);
            //这个构造函数中指明了调用父类的有参构造函数,若不指定,则调用父类无参构造函数
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            Child---执行静态代码块了1!
//            Child---执行静态代码块了2!
//            Parent---执行非静态代码块了1!
//            Parent---执行非静态代码块了2!
//            Parent---有参构造函数!
//            Child---执行非静态代码块了1!
//            Child---执行非静态代码块了2!
//            Child---有参构造函数!
            说明:静态代码块或非静态代码块执行顺序,按照代码前后编写顺序。
        case 3:
            Child d= new Child();
            Child e= new Child(4);
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            Child---执行静态代码块了1!
//            Child---执行静态代码块了2!
//            Parent---执行非静态代码块了1!
//            Parent---执行非静态代码块了2!
//            Parent---无参构造函数!
//            Child---执行非静态代码块了1!
//            Child---执行非静态代码块了2!
//            Child---无参构造函数!
//            Parent---执行非静态代码块了1!
//            Parent---执行非静态代码块了2!
//            Parent---有参构造函数!
//            Child---执行非静态代码块了1!
//            Child---执行非静态代码块了2!
//            Child---有参构造函数!
            说明:创建多个子类,但父类静态代码块只执行一次。
        case 4:
            Child.staticChildMethod(4);
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            Child---执行静态代码块了1!
//            Child---执行静态代码块了2!
//            Child---静态方法/staticChildNum=4
            说明:静态方法只可以调用静态变量。
        case 5:
            Parent.staticParentMethod(5);
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            Parent---静态方法/staticParentNum=5
            说明:静态方法可通过 父类名.静态方法() 调用。
        case 6:
            System.out.println("父类的静态变量值staticParentNum="+Parent.staticParentNum);
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            父类的静态变量值staticParentNum=0
            说明:调用静态变量时,静态代码块会执行。
        case 7:
            System.out.println("子类的静态变量值staticChildNum="+Child.staticChildNum);
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            Child---执行静态代码块了1!
//            Child---执行静态代码块了2!
//            子类的静态变量值staticChildNum=0
            说明:调用子类静态变量,父类静态代码块和子类静态代码块会被执行。
        case 8:
            System.out.println("父类的静态变量值staticParentNum="+Parent.staticParentNum);
            System.out.println("子类的静态变量值staticChildNum="+Child.staticChildNum);
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            父类的静态变量值staticParentNum=0
//            Child---执行静态代码块了1!
//            Child---执行静态代码块了2!
//            子类的静态变量值staticChildNum=0
            
        case 9:
            Child f= new Child();
            f.ParentMethod(3);
            break;
//            Parent---执行静态代码块了1!
//            Parent---执行静态代码块了2!
//            Child---执行静态代码块了1!
//            Child---执行静态代码块了2!
//            Parent---执行非静态代码块了1!
//            Parent---执行非静态代码块了2!
//            Parent---无参构造函数!
//            Child---执行非静态代码块了1!
//            Child---执行非静态代码块了2!
//            Child---无参构造函数!
//            Parent---非静态方法/parentNum=3
            说明:创建子类,用子类调用父类方法,非静态方法可以调用静态变量。

        default:
            break;
        }

    }

}
总结

Java代码初始化顺序

由 static 关键字修饰的(如:类变量(静态变量)、静态代码块)将在类被初始化创建实例对象之前被初始化,而且是按顺序从上到下依次被执行。静态(类变量、静态代码块)属于类本身,不依赖于类的实例。

没有 static 关键字修饰的(如:实例变量(非静态变量)、非静态代码块)初始化实际上是会被提取到类的构造器中被执行的,但是会比类构造器中的代码块优先执行到,非静态(实例变量、非静态代码块)的地位是相等的,它们将按顺序被执行。

类变量(静态变量)、实例变量(非静态变量)、静态代码块、非静态代码块的初始化时机

由 static 关键字修饰的(如:类变量[静态变量]、静态代码块)将在类被初始化创建实例对象之前被初始化,而且是按顺序从上到下依次被执行;

没有 static 关键字修饰的(如:实例变量[非静态变量]、非静态代码块)初始化实际上是会被提取到类的构造器中被执行的,但是会比类构造器中的 代码块优先执行到,其也是按顺序从上到下依次被执行。

容易混淆的一个知识点
静态方法只允许直接访问静态成员,而实例方法中可以访问静态成员和实例成员,原因是类还没有实例化,所实例成员也没有被创建,静态方法中因此也不能用this。

欢迎关注公众号交流!

文章版权归作者所有,未经允许请勿转载,若此文章存在违规行为,您可以联系管理员删除。

转载请注明本文地址:https://www.ucloud.cn/yun/73700.html

相关文章

  • Java 并发编程(学习)

    摘要:并发编程的挑战并发编程的目的是为了让程序运行的更快,但是,并不是启动更多的线程就能让程序最大限度的并发执行。的实现原理与应用在多线程并发编程中一直是元老级角色,很多人都会称呼它为重量级锁。 并发编程的挑战 并发编程的目的是为了让程序运行的更快,但是,并不是启动更多的线程就能让程序最大限度的并发执行。如果希望通过多线程执行任务让程序运行的更快,会面临非常多的挑战:(1)上下文切换(2)死...

    NervosNetwork 评论0 收藏0
  • 深入理解Java内存模型(三)——顺序一致性

    摘要:下面是该程序在两个内存模型中的执行时序对比图在顺序一致性模型中,所有操作完全按程序的顺序串行执行。不保证未同步程序的执行结果与该程序在顺序一致性模型中的执行结果一致。 前情提要 深入理解Java内存模型(二)——重排序 数据竞争与顺序一致性保证 当程序未正确同步时,就会存在数据竞争。java内存模型规范对数据竞争的定义如下: 在一个线程中写一个变量, 在另一个线程读同一个变量,...

    aristark 评论0 收藏0
  • 《深入理解 Java 内存模型》读书笔记

    摘要:前提深入理解内存模型程晓明著,该书在以前看过一遍,现在学的东西越多,感觉那块越重要,于是又再细看一遍,于是便有了下面的读书笔记总结。同步同步是指程序用于控制不同线程之间操作发生相对顺序的机制。线程之间的通信由内存模型控制。 showImg(https://segmentfault.com/img/remote/1460000013474312?w=1920&h=1271); 前提 《深...

    xuexiangjys 评论0 收藏0
  • 《深入理解 Java 内存模型》读书笔记

    摘要:前提深入理解内存模型程晓明著,该书在以前看过一遍,现在学的东西越多,感觉那块越重要,于是又再细看一遍,于是便有了下面的读书笔记总结。同步同步是指程序用于控制不同线程之间操作发生相对顺序的机制。线程之间的通信由内存模型控制。 showImg(https://mmbiz.qpic.cn/mmbiz_jpg/1flHOHZw6RtPu3BNx3zps1JhSmPICRw7QgeOmxOfTb...

    姘存按 评论0 收藏0
  • Java并发编程:从根源上解析volatile关键字的实现

    摘要:并发编程关键字解析解析概览内存模型的相关概念并发编程中的三个概念内存模型深入剖析关键字使用关键字的场景内存模型的相关概念缓存一致性问题。事实上,这个规则是用来保证程序在单线程中执行结果的正确性,但无法保证程序在多线程中执行的正确性。 Java并发编程:volatile关键字解析 1、解析概览 内存模型的相关概念 并发编程中的三个概念 Java内存模型 深入剖析volatile关键字 ...

    CNZPH 评论0 收藏0
  • 深入理解Java内存模型(二)——重排序

    摘要:前情提要深入理解内存模型一基础编译器运行时会对指令进行重排序。以处理器的猜测执行为例,执行线程的处理器可以提前读取并计算,然后把计算结果临时保存到一个名为重排序缓冲的硬件缓存中。请看下篇深入理解内存模型三顺序一致性 前情提要 深入理解Java内存模型(一)——基础 Java编译器、运行时会对指令进行重排序。这种重排序在单线程和多线程情况下分别有什么影响呢? 数据依赖性 如果两个操...

    tunny 评论0 收藏0

发表评论

0条评论

最新活动
阅读需要支付1元查看
<