精华内容
下载资源
问答
  • 静态代码块和非静态代码块什么时候执行?
    千次阅读
    2021-12-20 19:52:23

    静态代码块和非静态代码块什么时候执行?

    静态代码块随着类的加载而加载,非静态代码块随着对象的加载而加载
    所以静态代码块再调用类的时候执行。非静态代码块创建对象时或者通过反射获取其类信息的时候执行

    更多相关内容
  • 下面小编就为大家带来一篇Java 普通代码块静态代码块执行顺序(实例讲解)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 主要介绍了java 代码块与静态代码块加载顺序的相关资料,需要的朋友可以参考下
  • 主要介绍了Java静态代码块作用及执行顺序解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • 本篇文章介绍了,Java中的static静态代码块的使用详解。需要的朋友参考下
  •  1 静态变量,静态代码块(类加载时执行,类不加载不执行)  2 实例变量,实例代码块(创建对象时才执行,不创建对象不执行)  3 构造函数,(创建对象时执行完2后再执行构造函数,不管构造函数是public还是private...
  •  其中静态代码在类的初始化阶段被初始化。而非静态代码则在类的使用阶段(也是实例化一个类的时候)才会被初始化。  静态变量  可以将静态变量理解为类变量(与对象无关),而实例变量则属于一个特定的对象...
  • 下面小编就为大家带来一篇java中的静态代码块、构造代码块、构造方法详解。小编觉得挺好的,现在分享给大家。给大家一个参考。一起跟随小编过来看看吧
  • 静态代码块

    2015-10-21 10:50:31
    在Java中静态代码块的使用,及静态代码块的相关基础知识
  • 主要给大家介绍了关于Java中静态代码块执行的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧。
  • Static静态代码块以及各代码块之间的执行顺序

    万次阅读 多人点赞 2019-10-16 19:56:49
    在Java中,Static静态代码块、构造代码块、普通代码块、构造函数的执行顺序是一个java学习者必须掌握的基础,本篇博客旨在让大家能清除了解它们之间的执行顺序。 文章目录代码块的分类1、静态代码块(也叫静态块、...

    前言
    在Java中,Static静态代码块、构造代码块、普通代码块、构造函数的执行顺序是一个java学习者必须掌握的基础,本篇博客旨在让大家能清除了解它们之间的执行顺序。

    代码块的分类

    基本上代码块分为三种:Static静态代码块、构造代码块、普通代码块

    代码块执行顺序静态代码块——> 构造代码块 ——> 构造函数——> 普通代码块

    继承中代码块执行顺序:父类静态块——>子类静态块——>父类代码块——>父类构造器——>子类代码块——>子类构造器

    1、静态代码块(也叫静态块、静态初始化块)

    Java静态代码块中的代码会在类加载JVM时运行,且只被执行一次,也就是说这些代码不需要实例化类就能够被调用。一般情况下,如果有些代码必须在项目启动的时候就执行的时候,就需要使用静态代码块,所以静态块常用来执行类属性的初始化!

    关于Static静态代码块的五个小结点

    1、Java静态代码块中的代码会在类加载JVM时运行,且只被执行一次
    2、静态块常用来执行类属性的初始化
    3、静态块优先于各种代码块以及构造函数,如果一个类中有多个静态代码块,会按照书写顺序依次执行
    4、静态代码块可以定义在类的任何地方中除了方法体中【这里的方法体是任何方法体】
    5、静态代码块不能访问普通变量

    针对4中描述静态代码块不能存在任何方法体中的原因其实也是很简单,由于普通方法是通过加载类,然后new出实例化对象,通过对象才能运行这个方法,而静态代码块只需要加载类之后就能运行了。对于静态方法,在类加载的时候,静态方法也已经加载了,但是我们必须要通过类名或者对象名才能访问,也就是说相比于静态代码块,静态代码块是自己主动运行的,而静态方法是被动调用运行的。不管是哪种方法,我们需要明确静态代码块的存在在类加载的时候就自动运行了,而放在不管是普通方法还是静态方法中,都是不能自动运行的。

    针对5中描述静态代码块不能访问普通变量,原因同样简单。普通变量是被实例对象调用的,静态代码块中都不存在其实例对象,谈何调用变量?

    Static静态代码块使用格式

    static{
      ..............
    }
    

    2、构造代码块(也叫构造初始化块)

    听这名字就知道和构造方法离不开!没错,但是还是和构造方法有着本质区别,我们都知道,没个方法中都可以有很多构造方法,每创建一个对象其构造方法就执行一个,而一个构造方法可以创建N个对象,构造方法就比较“高冷”了,而构造代码块就比较“舔狗”了,只要该类实例了一个对象,构造代码就执行一次,利用每次创建对象的时候都会提前调用一次构造代码块特性,所以它可以做统计创建对象的次数功能。当然构造代码块用的相对少!

    构造代码块小结

    1、构造代码块在创建对象时被调用,每次创建对象都会调用一次
    2、构造代码块优先于构造函数执行,同时构造代码块的运行依赖于构造函数
    3、构造代码块在类中定义

    针对2中的“依赖”可理解为如果不实例化对象(也就是不执行构造方法),构造代码块是不会执行的!

    3、代码块(又叫普通代码块、初始化块)

    代码块小结

    1、普通代码块定义在方法体中
    2、普通代码块与构造代码块的格式一致都是{}
    3、普通代码块与构造代码块唯一能直接看出的区别是构造代码块是在类中定义的,而普通代码块是在方法体中定义的

    执行顺序的代码测试

    以上已经讲得差不多了,开始上代码了!

    package com.gx.initializationblock;
    
    public class Initializationblock {
    
        int intA;
        int intB;
    
    
        public Initializationblock() {
            System.out.println("无参构造器00000000");
        }
    
        public Initializationblock(int a) {
            System.out.println("一个参数的构造器");
            
        }
    
    
        {
            intA = 10;
            intB = 15;
    
            System.out.println("构造初始化块11111");
        }
    
        {
            System.out.println("构造初始化块22222");
        }
    
        {
        	
            System.out.println("构造初始化块33333");
        }
    
        //静态初始化块
        static {
            System.out.println("静态初始化块01010101");
        }
    
        static {
            System.out.println("静态初始化块0202020202");
        }
        public void method(){
        	{
        		System.out.println("普通初始化块");
        	}
        }
    }
    

    测试demo

    package com.gx.initializationblock;
    
    /* 初始化块一
    	 * 因为静态块是在类的初始化阶段完成的,
    	 * 因此在创建某个类的第二个对象时,该类的静态块就不会执行了
    	 * 
    	 * 在单个类中,静态初始化块,初始化块,构造器
    	 * 多个类的继承中初始化块、静态初始化块、构造器的执行顺序
    在继承中,先后执行父类A的静态块,父类B的静态块,最后子类的静态块,然后再执行父类A的非静态块和构造器,然后是B类的非静态块和构造器,最后执行子类的非静态块和构造器
     */
    public class Demo1 {
        public static void main(String[] args) {
            Initializationblock initializationblock = new Initializationblock();
            initializationblock.method();
            System.out.println("------------");
            //多打印几个对象的目的是:好看出Static静态代码块只执行一次!!!
            Initializationblock initializationblock2 = new Initializationblock(); //因为静态块是在类的初始化阶段完成的,因此在创建某个类的第二个对象时,该类的静态块就不会执行了
            initializationblock2.method();
            Initializationblock initializationblock3 = new Initializationblock();
            initializationblock3.method();
        }
    }
    

    打印结果

    静态初始化块01010101
    静态初始化块0202020202
    构造初始化块11111
    构造初始化块22222
    构造初始化块33333
    无参构造器00000000
    普通初始化块
    ------------
    构造初始化块11111
    构造初始化块22222
    构造初始化块33333
    无参构造器00000000
    普通初始化块
    构造初始化块11111
    构造初始化块22222
    构造初始化块33333
    无参构造器00000000
    普通初始化块
    

    得出结论:执行顺序静态代码块 > 构造代码块 > 构造函数 > 普通代码块

    继承中各代码块的执行顺序

    啥都不说了,直接撸代码:继承关系为 BaseThree——> BaseTwo——> BaseOne
    BaseOne类

    package com.gx.initializationblock;
    
    public class BaseOne {
    
        public BaseOne() {
            System.out.println("BaseOne构造器");
        }
    
        {
            System.out.println("BaseOne初始化块");
            System.out.println();
        }
    
        static {
            System.out.println("BaseOne静态初始化块");
    
        }
    
    }
    

    BaseTwo类

    package com.gx.initializationblock;
    
    public class BaseTwo extends BaseOne {
        public BaseTwo() {
            System.out.println("BaseTwo构造器");
        }
    
        {
            System.out.println("BaseTwo初始化块");
        }
    
        static {
            System.out.println("BaseTwo静态初始化块");
        }
    }
    

    BaseThree 类

    package com.gx.initializationblock;
    
    public class BaseThree extends BaseTwo {
        public BaseThree() {
            System.out.println("BaseThree构造器");
        }
    
        {
            System.out.println("BaseThree初始化块");
        }
    
        static {
            System.out.println("BaseThree静态初始化块");
        }
    }
    

    测试demo2类

    package com.gx.initializationblock;
    
    /*
         注:这里的ABC对应BaseOne、BaseTwo、BaseThree 
     * 多个类的继承中初始化块、静态初始化块、构造器的执行顺序
         在继承中,先后执行父类A的静态块,父类B的静态块,最后子类的静态块,
         然后再执行父类A的非静态块和构造器,然后是B类的非静态块和构造器,最后执行子类的非静态块和构造器
     */
    public class Demo2 {
        public static void main(String[] args) {
            BaseThree baseThree = new BaseThree();
            System.out.println("-----");
            BaseThree baseThree2 = new BaseThree();
    
        }
    }
    

    运行结果

    BaseOne静态初始化块
    BaseTwo静态初始化块
    BaseThree静态初始化块
    BaseOne初始化块
    
    BaseOne构造器
    BaseTwo初始化块
    BaseTwo构造器
    BaseThree初始化块
    BaseThree构造器
    -----
    BaseOne初始化块
    
    BaseOne构造器
    BaseTwo初始化块
    BaseTwo构造器
    BaseThree初始化块
    BaseThree构造器
    

    多个类的继承中初始化块、静态初始化块、构造器的执行顺序为:先后执行父类A的静态块,父类B的静态块,最后子类的静态块,然后再执行父类A的非静态块和构造器,然后是B类的非静态块和构造器,最后执行子类的非静态块和构造器【注:这里的ABC对应BaseOneBaseTwoBaseThree

    结论:多个类的继承中初始化块、静态初始化块、构造器的执行顺序为:父类静态块——>子类静态块——>父类代码块——>父类构造器——>子类代码块——>子类构造器

    如果本文对你有所帮助,请支持一下点个赞呗QnQ
    最后,博主并不是什么大牛,也会犯错!如有不正之处欢迎指正!感激不尽!

    展开全文
  • Java的静态代码块、非静态代码块、构造函数的简单的java代码
  • java代码-日常练习33,代码块### 静态代码块 static{代码内容;} 随着类的加载就执行一次 构造器代码块 {代码内容;} 每创建对象就执行一次 局部代码块 {代码内容;} 方法执行一次执行一次
  • 静态代码块:是用来初始化类的信息,在类被加载的时候就会被执行,且只执行一次。执行优先级高于非静态的初始化块。 非静态代码块:是用来初始化类的实例信息,在创建对象的时候就会被执行,且每创建一个对象都会被...

    静态代码块:是用来初始化类的信息,在类被加载的时候就会被执行,且只执行一次。执行优先级高于非静态的初始化块。

    非静态代码块:是用来初始化类的实例信息,在创建对象的时候就会被执行,且每创建一个对象都会被执行一次。执行的时候如果有静态初始化块,先执行静态初始化块再执行非静态初始化块,非静态初始化块会在构造函数执行时,在构造函数主体代码执行之前被运行。

    构造方法:是用来创建对象的。

    一、同类中静态代码块,非静态代码块,构造方法的执行顺序

    执行顺序:静态代码块>非静态代码块>构造方法

    即:程序在执行时,首先执行静态代码块,且只执行一次。接下来再创建对象时(new),首先执行非静态代码块,再执行构造方法。

    示例1:

    代码:

    package com.csu.marden;
    
    public class Demo {
    	static{
    		System.out.println("static");
    	}
    	{
    		System.out.println("no static");
    	}
    	Demo5(){
    		System.out.println("constructor");
    	}
    	
    	
    	
    	public static void main(String[] args) {
    		
    	}
    
    }
    

    执行结果:

    分析:

    上述Demo类包含静态代码块,非静态代码块和构造方法。但是该类中没有具体的执行,只完成了类的加载,即只有静态代码块在类加载的时候被执行,且只执行一次。由于没有对类的实例化,所有非静态代码块和构造方法均未执行。

     

     

    示例2:

    代码:

    package com.csu.marden;
    
    public class Demo5 {
    	static{
    		System.out.println("static");
    	}
    	{
    		System.out.println("no static");
    	}
    	Demo5(){
    		System.out.println("constructor");
    	}
    	
    	
    	
    	public static void main(String[] args) {
    		Demo demo=new Demo();
    	}
    
    }
    

    执行结果:

    分析:

    上述Demo类包含静态代码块,非静态代码块和构造方法。上述代码首先完成了类加载,即静态代码块执行,且仅执行一次。然后创建了该类的实例,首先执行了非静态代码块,然后执行了构造方法。

     

     

    示例3:

    代码:

    package com.csu.marden;
    
    public class Demo5 {
    	static{
    		System.out.println("static");
    	}
    	{
    		System.out.println("no static");
    	}
    	Demo5(){
    		System.out.println("constructor");
    	}
    	
    	
    	
    	public static void main(String[] args) {
    		Demo demo1=new Demo();
    		Demo demo2=new Demo();
    	}
    
    }
    

    执行结果:

    分析:

    上述Demo类包含静态代码块,非静态代码块和构造方法。上述代码首先完成了类加载,即静态代码块执行,且仅执行一次。然后创建了该类的两个实例,首先执行了非静态代码块,然后执行了构造方法。并且非静态代码块和构造方法,在每次创建新的对象时,都会被执行一次。

     

    二、父类和子类中静态代码块,非静态代码块,构造方法的执行顺序

    在Java继承中,父类子类构造方法、静态代码块、非静态代码块的执行顺序:

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

    示例1:

    代码:

    //父类
    public class Parent {
        static String name = "hello";
        {
            System.out.println("parent-no-block");
        }
        static {
            System.out.println("parent-static");
        }
    
        public Parent() {
            System.out.println("parent-constructor");
        }
        
    }
    
    
    
    //子类
    public class Child extends Parent {
        static String childName = "hello";
        {
            System.out.println("child-no-static");
        }
        static {
            System.out.println("child-static");
        }
    
        public Child() {
            System.out.println("child-constructor");
        }
    }
    
    
    
    
    //测试类
    public class Demo {
    	public static void main(String[] args) {
    		new Child();
    	}
    }
    
    
    
    

    执行结果:

    分析:

    Java继承体系中,若子类继承了父类,在创建子类的时候,首先会调用父类的构造方法和非静态代码块完成类实例的初始化,然后调用子类的构造方法和非静态代码块完成类实例的初始化(子类需要根据父类的构造方法生成)。

    所以在执行时(创建子类对象时),首先加载父类,即执行父类的静态代码块,且只执行一次,然后加载子类,即执行子类的静态代码块,同样只执行一次。然后执行父类的非静态代码块和构造方法完成父类实例的初始化,最后执行子类的非静态代码块和构造方法完成子类实例的初始化。

     

     

    示例2:

    代码:

    //父类
    public class Parent {
        static String name = "hello";
        {
            System.out.println("parent-no-block");
        }
        static {
            System.out.println("parent-static");
        }
    
        public Parent() {
            System.out.println("parent-constructor");
        }
        
    }
    
    
    
    //子类
    public class Child extends Parent {
        static String childName = "hello";
        {
            System.out.println("child-no-static");
        }
        static {
            System.out.println("child-static");
        }
    
        public Child() {
            System.out.println("child-constructor");
        }
    }
    
    
    
    
    //测试类
    public class Demo {
    	public static void main(String[] args) {
    		new Child();
            new Child();
    	}
    }
    
    
    
    

    执行结果:

    分析:

    在执行时(创建子类对象时),首先加载父类,即执行父类的静态代码块,且只执行一次,然后加载子类,即执行子类的静态代码块,同样只执行一次。然后执行父类的非静态代码块和构造方法完成父类实例的初始化,最后执行子类的非静态代码块和构造方法完成子类实例的初始化。由于本例中创建了两个子类对象,所以执行两次父类非静态代码块和构造函数,子类非静态代码块和构造函数。

     

     

     

     

    展开全文
  • Java 静态代码块详解

    千次阅读 多人点赞 2020-05-31 11:22:14
    静态代码块及多种代码块的相关知识


    首先得知道什么是初始化块:就是类中得一段用大括号 {} 括起来得独立的代码空间。
    而初始化块分成了 普通初始化块静态的初始化块(也称为 静态代码块)。

    下面分别来介绍一下:

    一、普通初始化块:

    1. 普通初始化块是类中用一个大括号 {} 包起来的独立的代码空间,一个类中可以有多个初始化块。

    2. 普通初始化块是在创建对象时隐式调用,每次创建一个新对象实例时都会调用一次,多个普通初始化块之间,按顺序调用。

      (可以看到,先执行普通初始化块中的代码,然后再执行类的构造函数;并且每次创建对象都会执行类中的普通初始化块。)

    二、静态代码块:

    1. static {} 包起来的代码,一个类中可以有多个静态代码块。

    2. 类加载时隐式调用,只执行一次。

      (可以看到,多次创建对象,但一个类的静态代码块只会执行一次。)

    三、多种代码块间的执行顺序

    类中既有既有静态代码块又有普通初始化块
    代码块执行顺序:
    静态代码块 → 普通初始化块 → 构造函数

    因为要先加载类,才能创建类的对象实例,而静态代码块是在类加载时调用,而普通初始化块是在创建对象时调用,所以自然静态代码块的执行早于普通初始化块。
    示例:

    测试:

    1. 子父类中都有静态代码块初始化块

    代码块执行顺序:
    父类静态代码块 → 子类静态代码块 → 父类初始化块 → 父类构造函数 → 子类初始化块 → 子类构造函数

    父类:

    子类:

    测试:

    其他的顺序都好理解,可能有些人不理解:为什么父类的构造函数比子类的初始化块先执行?
    因为如果你创建某个类的对象,而这个类具有继承关系,他必然要先执行自己父类的构造函数,然后再执行自己的构造函数,也就是说,在子类创建之前,要先执行父类的构造函数,而初始化块是在创建对象时执行,所以父类构造函数的执行也在子类的初始化块之前。


    上面就是关于静态代码块的相关内容了,如果看完之后,还有相关问题的不知道,可以在评论区留下问题,会及时回答更新。

    点个关注,不再迷路

    这里是猿兄,为你分享程序员的世界。

    非常感谢各位优秀的程序员们能看到这里,如果觉得文章还不错的话,
    求点赞👍 求关注💗 求分享👬
    对我来说真的 非常有用!!!

    注: 如果猿兄这篇博客有任何错误和建议,欢迎大家留言,不胜感激!

    展开全文
  • 本案例是一个通过静态代码块获取资源属性文件的代码块,从而来提高应用性能。。
  • java中我们通常将static修饰的代码块,称为静态代码块,随类存在,仅在类初始化时执行一次,那么类在什么时候初始化,主要有以下六种:  1)创建类的实例,也就是new一个对象  2)访问某个类或接口的静态变量,...
  • 主要介绍了Java 中普通代码块,构造代码块,静态代码块区别及代码示例的相关资料,需要的朋友可以参考下
  • java静态代码块与非静态代码块.doc
  • 主要介绍了Java构造代码块,静态代码块,结合实例形式分析了Java构造代码块,静态代码块的功能、原理、用法及操作注意事项,需要的朋友可以参考下
  • 主要介绍了Java中普通代码块、构造代码块与静态代码块的相关资料,静态代码块>Main()>构造代码块。非常不错,具有参考借鉴价值,需要的朋友可以参考下
  • java中静态代码块详解

    千次阅读 2021-02-26 12:43:02
    今天在项目中看到这行代码,静态代码块,很久没用静态代码块了,今天来复习一下,依旧按照为什么?是什么?怎么用?的思想,去学习。【为什么?】先说说代码中为什么要使用这种写法吧,还记得静态代码块的特点吗?...
  • 静态方法在访问本类的成员时,只允许访问静态成员(即静态成员变量和静态方法),注意图一,调用静态方法时只执行了静态代码块和静态方法,而不允许访问实例成员变量和实例方法;实例方法则无此限制 static{}静态...
  • 构造代码块和静态代码块的执行时机
  • java静态代码块与非静态代码块比较

    千次阅读 2018-10-23 00:20:45
    得出结论1:非静态代码块不会在调用方法与成员时执行.     结论2:非静态代码块在创建实例时...结论4:静态代码块优先非静态代码块优先构造函数,无论如何访问类(实例化,调用函数,成员),都会执行静态代码块 ...
  • 类加载时是否会执行静态代码块?杂谈问答解总结 杂谈 厦门的口罩都卖完了,前几天都开始摇号卖口罩了,太难了,今天是大年初十,可比去年大年初一还冷清,而且随着疫情的发展,我明显能感觉到周围的朋友情绪不断的...
  • 1、静态代码块(静态初始化块,静态域): 使用static关键字和{}声明的代码块,格式如下: public class People{ static{ System.out.println("静态代码块"); } } 作用: 需要在项目启动时就执行的代码...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 564,004
精华内容 225,601
关键字:

静态代码块