精华内容
下载资源
问答
  • java静态代码块与非静态代码块比较

    千次阅读 2018-10-23 00:20:45
    得出结论1:非静态代码块不会在调用...结论3:非静态代码块每次创建实例时执行,而静态代码块执行一次 结论4:静态代码块优先非静态代码块优先构造函数,无论如何访问类(实例化,调用函数,成员),都会执行静态代码块 ...

     

    得出结论1:非静态代码块不会在调用方法与成员时执行.

     

     

    结论2:非静态代码块在创建实例时执行

     

    结论3:非静态代码块每次创建实例时执行,而静态代码块只执行一次

    结论4:静态代码块优先非静态代码块优先构造函数,无论如何访问类(实例化,调用函数,成员),都会执行静态代码块

    展开全文
  • 静态代码块常用于加载静态资源(图片、音频、视频)package test.chongzai.chongxie;public class Goo { public static void main(String[] args) { Hoo h1 = new Hoo();//结果:静态代码块,构造方法 Hoo h2 = ...

    静态代码块常用于加载静态资源(图片、音频、视频)

    package test.chongzai.chongxie;
    
    public class Goo {
    
        public static void main(String[] args) {
            Hoo h1 = new Hoo();//结果:静态代码块,构造方法
            Hoo h2 = new Hoo();//结果:构造方法
    
        }
    
    
    }
    class Hoo{
        int a;
        public Hoo(){
            System.out.println("构造方法");
        }
        static{
            System.out.println("静态代码块");
        }
    }
    
    展开全文
  • java 类中的静态域的初始化和静态代码块的执行只在类加载的时候执行且只执行一次。 仅执行一次,所以这一定是线程安全的,由此引出的在单例设计模式中采用静态内部类中的静态域存储唯一一个实例,既保证了线程安全...

    java 类中的静态域的初始化和静态代码块的执行只在类加载的时候执行且只执行一次。

    仅执行一次,所以这一定是线程安全的,由此引出的在单例设计模式中采用静态内部类中的静态域存储唯一一个实例,既保证了线程安全又保证了懒加载,此技术被称作(initialization on demand holder)。但不在本文讨论范围。

    本文旨在验证静态代码块只执行一次,即线程安全。

     

    我需要设计一个类,静态代码块需要执行较长时间,然后在测试方法中以多线程的方式触发此类的加载,然后检验结果,验证线程安全。

     

    本人才疏学浅,如有错误请不吝赐教。

    另外请尊重别人的劳动成果,如需转载请注明出处:

     http://waitingkkk-163-com.iteye.com/blog/2231416

     

    需要“较长时间加载”的类:

    public class SlowInit {
        static{
            System.out.println(Thread.currentThread().getName() + " class SlowInit begin to init static block");
            try{
                TimeUnit.SECONDS.sleep(5);
            }catch(Exception e){
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + " class SlowInit static block init over");
        }
    
        public static void say(){
            System.out.println(Thread.currentThread().getName() + " say: hi~" );
        };
    }

     

    测试类:

    public class ConcurrencyTest {
    
        private static CountDownLatch startGate = new CountDownLatch(1);
    
        public static void main(String args[]){
            for(int i=0; i<100; i++){
                new Thread(task).start();
            }
            startGate.countDown();
        }
    
        private static Runnable task = new Runnable() {
            @Override
            public void run() {
                try {
                    startGate.await();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
                SlowInit.say();
            }
        };
    }

     

    测试类中采用CountDownLatch技术模拟100个线程同时启动,然后都会触发SlowInit类的类加载。

    测试结果如下:

    Thread-33 class SlowInit begin to init static block
    Thread-33 class SlowInit static block init over
    Thread-33 say: hi~
    Thread-96 say: hi~
    Thread-91 say: hi~
    Thread-87 say: hi~
    Thread-97 say: hi~
    Thread-77 say: hi~
    Thread-1 say: hi~
    ……
    ……
    ……

     可以发现,只有一个线程可以触发类的加载过程,且在此类加载过程中,其他线程处于阻塞状态, 等待类加载的完成。

    即:

    java 静态代码块只在类加载时执行一次

    展开全文
  • Java 静态代码块和非静态代码块

    万次阅读 2016-08-10 21:09:42
    参考:http://uule.iteye.com/blog/1558891Java中的静态代码块是在虚拟机加载类的时候,就执行的,而且只执行一次。如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行...

    参考:http://uule.iteye.com/blog/1558891

    Java中的静态代码块是在虚拟机加载类的时候,就执行的,而且只执行一次。如果static代码块有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码块只会被执行一次。

    非静态代码块是在类new一个实例的时候执行,而且是每次new对象实例都会执行。

    代码的执行顺序

    1. 主调类的静态代码块
    2. 对象父类的静态代码块
    3. 对象的静态代码块
    4. 对象父类的非静态代码块
    5. 对象父类的构造函数
    6. 对象的非静态代码块
    7. 对象的构造函数

    示例代码

    public class StaticBlockTest1 {
    
        //主调类的非静态代码块
        {
            System.out.println("StaticBlockTest1 not static block");
        }
        //主调类的静态代码块
        static {
            System.out.println("StaticBlockTest1 static block");
        }
    
        public StaticBlockTest1(){
            System.out.println("constructor StaticBlockTest1");
        }
    
        public static void main(String[] args) {
            Children children = new Children();
            children.getValue();
        }
    
    }
    
    
    class Parent{
    
        private String name;
        private int age;
    
        //父类无参构造方法
        public Parent(){
            System.out.println("Parent constructor method");
            {
                System.out.println("Parent constructor method--> not static block");
            }
        }
        //父类的非静态代码块
        {
            System.out.println("Parent not static block");
            name = "zhangsan";
            age = 50;
        }
        //父类静态代码块
        static {
            System.out.println("Parent static block");
        }
    
        //父类有参构造方法
        public Parent(String name, int age) {
            System.out.println("Parent constructor method");
            this.name = "lishi";
            this.age = 51;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    
    class Children extends Parent{
        //子类静态代码块
        static {
            System.out.println("Children static block");
        }
    
        //子类非静态代码块
        {
            System.out.println("Children not static block");
        }
    
        //子类无参构造方法
        public Children(){
            System.out.println("Children constructor method");
        }
    
    
        public void getValue(){
            //this.setName("lisi");
            //this.setAge(51);
            System.out.println(this.getName() + this.getAge());
        }
    }

    输出结果

    StaticBlockTest1 static block   //主调类的静态代码块
    Parent static block             //父类的静态代码块
    Children static block           //子类的静态代码块
    Parent not static block         //父类的非静态代码块
    Parent constructor method       //父类的构造函数
    Parent constructor method--> not static block
    Children not static block       //主调类的非静态代码块
    Children constructor method     //主调类的构造函数
    zhangsan50                      //主调main方法

    总结:

    1. 按照前面提到的顺序执行
    2. 子类定义无参构造方法,调用的父类也是无参构造方法
    展开全文
  • java静态代码块面试题 public class Father { static{ System.out.println(&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;quot;Father___的静态代码块&amp;amp;amp;amp;amp;amp;amp;amp;amp;amp;amp...
  • 除了说普通代码块,静态代码块,构造代码块的执行顺序外,还有静态方法,静态变量等,都放在一起的话,这个执行顺序,怎么确定。... System.out.println("静态代码块执行:loading line"); } public static String s
  • 静态代码块:用staitc声明,jvm加载类时执行,仅执行一次 构造代码块:类中直接用 {} 定义,每一次创建对象时执行。 构造函数:创建对象时执行 执行顺序优先级:静态代码块 > 构造代码块 > 构造函数。 静态代码...
  • 静态代码块只在第一次new执行一次,之后不再执行,而非静态代码块在每new一次就执行一次。非静态代码块可在普通方法中定义(不过作用不大);而静态代码块不行。静态代码块和非静态代码块都是在JVM加载类时且在构造...
  • java静态代码块在什么时候会执行

    千次阅读 2019-04-16 21:05:41
    个类被主动使用时,Java虚拟就会对其初始化,如下六种情况为主动使用: 当创建某个类的新实例时(如通过new或者反射,克隆,反序列化等) 当调用某个类的静态方法时 当使用某个类或接口的静态字段时 当调用...
  • java静态代码块

    2019-01-10 19:23:44
    静态代码块是给类进行初始化的,随着类的加载而执行,并且只执行一次 格式:static{} 构造代码块是给对象进行初始化的,随着类的加载而加载,随着对象的创建而执行,每新建一个对象,就执行一次。 格式:{} 代码...
  • java静态代码块详解

    万次阅读 多人点赞 2019-04-17 18:05:42
    今天在项目中看到这行代码,静态代码块,很久没用静态代码块了...对,没错,就是这个,上面的代码就是因为这个特点而这样写的,可以使得静态代码块中的代码只执行一次,不需要每次调用这个变量都给它赋值。 【是...
  • 静态代码块以及构造函数的执行先后顺序,一直很迷惑,现用下面的这段小程序来简明扼要的叙述一下,以加深理解,与君共勉....    public class Fu {  static {
  • Java静态代码块和静态方法

    千次阅读 2018-07-19 10:47:41
    1 静态代码块:有些代码必须在项目启动的时候就执行,这种代码是主动执行的(当类被载入时,静态代码块被执行,且只被执行一次,静态块常用来执行类属性的初始化) 2 静态方法:需要在项目启动的时候就初始化,在不...
  • java 静态代码块

    千次阅读 2010-05-27 10:17:00
    java 静态代码块 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的...
  • java static 静态代码块是最先执行的,然后再是spring 相关注入。静态代码块先加载,项目启动就会报错。 我们怎么给静态变量注入,并在静态代码中使用呢? 参数配置:application.properties sc.crm.upDirPath=...
  • 知道java的初始化顺序为先执行父类的静态属性初始化(静态变量,静态初始化块,无先后顺序,按代码顺序执行初始化),然后执行子类的静态属性的初始化 之前做过如下面代码的笔试题...静态代码块"); } { Sy...
  • //其中静态代码块执行一次。构造代码块在每次创建对象是都会执行。 1 普通代码块 普通代码块:在方法或语句中出现的{}就称为普通代码块。普通代码块和一般的语句执行顺序由他们在代码中出现的次序决定--“先出现...
  • 、观察段源码与结果 public class StaticDemo { ...System.out.println("static前代码块执行顺序为"+i); i=i+1; } { System.out.println("非static代码块执行顺序为"+i); i=i+1; } public StaticDem
  • 今天有个同事问我关于代码块的问题 只记得静态代码块要提前执行 怕说错,查了资料,实测的一下,供大家参考 public class book { { System.out.println("这里是构造代码块");//所有类中有个默认的构造函数,...
  • 1. 基本概念1.1.静态代码块 静态代码块static { } 非静态代码块{ } 静态代码块和非静态代码块的异同点如下:相同点:都是JVM加载类时且在...静态代码块只在第一次new时执行一次,之后不再执行。而非静态代码块每ne
  • Java静态代码块和静态方法的区别

    千次阅读 2017-07-06 10:41:16
    Java 静态代码块 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的...
  • java 静态代码块 静态方法

    千次阅读 2008-10-21 17:39:00
    java 静态代码块 静态方法区别一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的时候,需要...
  • java静态代码块/静态属性、构造块、构造方法执行、main方法、普通代码块的顺序 这也是在笔试中的个重要的考点,就有个输出语句让你写出输出的结果。 理论知识: 静态代码块是:属于类的,在类加载时就自动执行。...
  • 这篇文章主要介绍了举例说明Java代码块执行顺序,包括静态属性和非静态属性以及构造函数等相关的执行先后,需要的朋友可以参考下 前言  今天在看Android ContentProvider实现的时候,突然想到了Java类在new...
  • JAVA静态代码块的作用

    千次阅读 2018-03-29 17:09:57
    般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码块,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情 况下,其他程序来调用的时候,需要使用静态方法,这种代码是被动...
  • java中的非静态代码块静态代码块
  • 深究静态代码块不被执行问题

    千次阅读 2020-05-22 20:16:02
    工具类中的静态代码块不被自动执行,工具类第一次被调用时静态代码块执行 通过子类调用继承的父类的方法,子类静态代码块不被执行 复习ClassLoad Java类加载 会初始化的情况有且仅有以下五种:(也称为主动引用) 1...
  • 它首先去看父类里面有没有静态代码块,如果有,它先去执行父类里面静态代码块里面的内容,当父类的静态代码块里面的内容执行完毕之后,接着去执行子类(自己这个类)里面的静态代码块,当子类的静态代码块执行完毕之后...
  • 1. 静态代码块在类加载时即运行,而且只运行一次,并且优先于各种代码块以及构造函数运行。如果一个类中有多个静态代码块,会按照书写顺序依次执行静态代码块不能访问普通变量(普通变量只能通过对象来调用)。 2. ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 189,441
精华内容 75,776
关键字:

java静态代码块执行一次

java 订阅