精华内容
下载资源
问答
  • PAGE / NUMPAGES java静态块非静态块 执行顺序 java中经常有一些静态块这是用来在生成类之前进行的初始化无论java还C++中的static都是最先初始化好的 所以注意 a在静态方法里只能直接调用同类中其他的静态成员包括...
  • java 静态块实例块构造器调用在继承中的调用顺序,包括代码及注释
  • 一直以为Java静态块抛异常,没人捕获,虚拟机会推出,要不是最近debug到异常的执行流程,观念还正不了,自己看吧。   二 代码 (1)静态块抛异常类 /** * 静态块抛异常类 */ public class App { ...

    一 背景

    一直以为Java静态块抛异常,没人捕获,虚拟机会推出,要不是最近debug到异常的执行流程,观念还正不了,自己看吧。

     

    二 代码

    (1)静态块抛异常类

    /**
     * 静态块抛异常类
     */
    public class App {
    
        static {
            System.out.println("static start !=============");
            if (true) {
                throw new RuntimeException("static test");
            }
            System.out.println("static finiah!=============");
        }
    
        public static void hello() {
            System.out.println("hello ! ");
        }
    }
    

     

    (2)调用类

    /**
     * 调用静态块
     */
    public class TestApp {
        public static void main(String[] args) {
            try {
                App.hello();
            } catch (Throwable e) {
                System.err.println("excepiton1 start : =========" );
                e.printStackTrace();
                System.err.println("excepiton1 finish! =========");
            }
    
            System.err.println("--------------------------------");
            try {
                App.hello();
            } catch (Throwable e) {
                System.err.println("excepiton2 start ! =========");
                e.printStackTrace();
                System.err.println("excepiton2 finish! =========");
            }
        }
    }

     

    三 执行结果

     

    static start !=============
    excepiton1 start : =========
    java.lang.ExceptionInInitializerError
    	at x.test.TestApp.main(TestApp.java:9)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
    Caused by: java.lang.RuntimeException: static test
    	at x.test.App.<clinit>(App.java:11)
    	... 6 more
    excepiton1 finish! =========
    --------------------------------
    excepiton2 start ! =========
    java.lang.NoClassDefFoundError: Could not initialize class x.test.App
    	at x.test.TestApp.main(TestApp.java:18)
    	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
    	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
    	at java.lang.reflect.Method.invoke(Method.java:498)
    	at com.intellij.rt.execution.application.AppMain.main(AppMain.java:147)
    excepiton2 finish! =========

     

    四 说明

    1)静态块在类首次使用时加载类后调用,如果调用过程产生异常,会抛到首次调用处,可以捕获。

    2)后续调用该类,会出现找不到类异常

    展开全文
  • Java 静态块、构造块、构造函数执行顺序

    请先参照这两个帖子:
    http://blog.csdn.net/kingzone_2008/article/details/45015301
    http://bbs.csdn.net/topics/391001417%20%22%22
    静态块:用static申明,JVM加载类时执行,仅执行一次
    构造块:类中直接用{}定义,每一次创建对象时执行
    执行顺序优先级:静态块>main()>构造块>构造方法
    静态块和静态属性优先执行,谁在前就先执行谁
    注意:
    1、每调用一次构造方法,则执行一次构造块
    2、静态块只在类加载的时候加载一次
    3、有多个静态变量或块时,按声明顺序加载

    public class Practice {  
        public static void main(String[] args) {  
            new Father();  
            new Son();  
        }  
    }  
    class Father {  
        protected int n = 5;  
        protected static int m = 5;
        public static Father p = new Father();
        public static Father p1 = new Father();
    
        {//构造块  
            n = n * 2;  
            m = m * 2;  
            System.out.print("父类**构造块**调用;");
            System.out.print("n="+n);  
            System.out.println("  m="+m);  
        }  
    
        static {//实例化多个对象时,静态块只执行一次,即在第一个实例化对象时执行
            m = m * 2;  
            System.out.println("父类%%静态块%%调用; m="+m);  
        }  
    
    
        public Father() {  //父类构造函数
            this.n = n * 10;  
            m = m + 10;  
            System.out.print("父类$$构造函数$$;   n="+n);  
            System.out.println("    m="+m);  
        }  
    }  
    
    class Son extends Father {  
        private int sn=3;  
        private static int sm=3;  
        static {  
            m = m + 2;  
            sm=sm+2;  
            System.out.println("【 子类 】@@ 静态块 @@调用;    m="+m);  
        }  
        {  
            n = n + 2;  
            sn=sn+2;  
            m = m + 2;  
            System.out.println("【 子类 】^^ 构造块 ^^调用;");  
            System.out.println("n="+n);  
            System.out.println("sn="+sn);  
            System.out.println("m="+m);  
        }  
    
        public Son() {  
            this.n = n + 10;  
            sn=sn+10;  
            m = m + 10;  
            System.out.println("【 子 类 】[[ 构造函数 ]];\nn="+n);  
            System.out.println("m="+m);  
        }  
    }   

    结果:(一)

    父类**构造块**调用;n=10  m=10
    父类$$构造函数$$;   n=100    m=20
    父类**构造块**调用;n=10  m=40
    父类$$构造函数$$;   n=100    m=50
    父类%%静态块%%调用; m=100
    父类**构造块**调用;n=10  m=200
    父类$$构造函数$$;   n=100    m=210
    【 子类 】@@ 静态块 @@调用;    m=212
    父类**构造块**调用;n=10  m=424
    父类$$构造函数$$;   n=100    m=434
    【 子类 】^^ 构造块 ^^调用;
    n=102
    sn=5
    m=436
    【 子 类 】[[ 构造函数 ]];
    n=112
    m=446
    

    结果(二):【将main()函数的new Son()注释掉的运行结果】

    **父类**构造块**调用;n=10  m=10
    父类$$构造函数$$;   n=100    m=20
    父类**构造块**调用;n=10  m=40
    父类$$构造函数$$;   n=100    m=50
    父类%%静态块%%调用; m=100
    父类**构造块**调用;n=10  m=200
    父类$$构造函数$$;   n=100    m=210**

    结果(三):【将Father类中的两个引用p、p1注释掉的运行结果,结果二中的new Son();也注释掉】

    父类%%静态块%%调用; m=10
    父类**构造块**调用;n=10  m=20
    父类$$构造函数$$;   n=100    m=30

    结果(四):【将Father类中的两个引用p、p1注释掉的运行结果,结果二中的new Son();不注释掉】

    父类%%静态块%%调用; m=10
    父类**构造块**调用;n=10  m=20
    父类$$构造函数$$;   n=100    m=30
    【 子类 】@@ 静态块 @@调用;    m=32
    父类**构造块**调用;n=10  m=64
    父类$$构造函数$$;   n=100    m=74
    【 子类 】^^ 构造块 ^^调用;
    n=102
    sn=5
    m=76
    【 子 类 】[[ 构造函数 ]];
    n=112
    m=86
    展开全文
  • Java 中的静态成员在类被实例化时或者调用类的静态成员时都会被加载,那java 的 static 还有什么作用那?
  • java构造块与静态块

    千次阅读 多人点赞 2018-04-07 12:19:33
    最近,在面试题或者面试上老是,提到静态块,静态变量,就仔细了解了下。Java类里普遍存在静态快,构造块,构造函数,具体什么关系呢?静态块:用static申明,JVM加载类时执行,仅执行一次构造块:类中直接用{}定义...

    最近,在面试题或者面试上老是,提到静态块,静态变量,就仔细了解了下。

    Java类里普遍存在静态快,构造块,构造函数,具体什么关系呢?

    静态块:用static申明,JVM加载类时执行,仅执行一次

    构造块:类中直接用{}定义,每一次创建对象时执行

    public class Study_static {
    	public static char text = 'a';  //静态对象
    	
    	public Study_static(){         //构造函数
    		System.out.println('c');
    	}
    	
    	{                              //构造块
    		System.out.println('b');
    	}
    	
    	static{                         //静态块
    		System.out.println(text);
    	}
    	public static void main(String[] args){
    		Study_static a = new Study_static();
    		
    	}
    }

    输出结果:

    执行顺序优先级:静态块>main()>构造块>构造方法

    所以先执行静态块,再tudy_static a = new Study_static();该语句创建对象,则又会调用构造块,输出构造块,再执行构造函数。

    然而,这里的静态块,并不是仅仅静态块,而是静态域,包含了静态变量,静态块,这两者的执行顺序就是按照位置顺序进行。

    总结:

    1.静态块其实就是给类初始化的,而构造代码块是给对象初始化的。

    2.静态代码块只会运行一次

    3.静态块中的变量是局部变量,与普通函数中的局部变量性质没有区别。
    一个类中可以有多个静态代码块,执行顺序按照位置决定。

    那么对于继承情况呢?

    public class Study_static {
    	public static char text = 'a';  //静态对象
    	
    	public Study_static(){         //构造函数
    		System.out.println('c');
    	}
    	
    	{                              //构造块
    		System.out.println('b');
    	}
    	
    	static{                         //静态块
    		System.out.println(text);
    	}
    }
    public class Study_static2 extends Study_static{
    	public static String text2 = "a1";
    	
    	public Study_static2(){
    		System.out.println("c2");
    	}
    	
    	{
    		System.out.println("b2");
    	}
    	
    	static{
    		System.out.println(text2);
    	}
    	public static void main(String[] args){
    		Study_static2 a = new Study_static2();
    		
    	}
    }

    结果:

    当涉及到继承时,按照如下顺序执行:

    1. 执行父类的静态代码块,并初始化父类静态成员变量
    2. 执行子类的静态代码块,并初始化子类静态成员变量
    3. 执行父类的构造代码块,执行父类的构造函数,并初始化父类普通成员变量
    4. 执行子类的构造代码块, 执行子类的构造函数,并初始化子类普通成员变量








    展开全文
  • java 静态代码.pdf

    2021-08-26 14:40:47
    java 静态代码.pdf
  • 主要介绍了Java静态代码加载驱动代码实例,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • Java 静态代码详解

    2020-05-31 11:22:14
    静态代码及多种代码的相关知识


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

    下面分别来介绍一下:

    一、普通初始化块:

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

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

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

    二、静态代码块:

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

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

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

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

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

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

    测试:

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

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

    父类:

    子类:

    测试:

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


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

    点个关注,不再迷路

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

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

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

    展开全文
  • JAVA的实例块和静态块

    千次阅读 2018-06-02 17:03:46
    实例块实例块就是一个划分的代码区域。{ 代码 }1.它是在构造器之前执行。2.它和属性初始化一同执行。3.一个类中可以有很多个实例块。...}静态块 静态块是类加载的时候和静态属性一起执行的。也是按顺序从上往...
  • 1. 什么是静态块?什么时候执行?有什么用? static { }计算机在使用类的时候都会先把这个类的字节码加载到内存中才能使用这个类,由类加载器把类的字节码加载到内存中,这一步就叫类加载。在应用程序的运行的生命...
  • 主要介绍了Java静态代码作用及执行顺序解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • java静态代码与非静态代码比较

    千次阅读 2018-10-23 00:20:45
    得出结论1:非静态代码不会在调用方法与成员时执行.     结论2:非静态代码在创建实例时...结论4:静态代码优先非静态代码优先构造函数,无论如何访问类(实例化,调用函数,成员),都会执行静态代码 ...
  • 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...
  • java 静态变量和静态块底层原理

    千次阅读 2013-11-04 15:57:29
    Java静态变量的初始化(static的本质) 在网上看到了下面的一段代码: public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) {
  • java 静态语句(static block)

    千次阅读 2016-03-28 14:19:58
    java 静态语句(static block)
  • java静态代码、非静态代码、构造器执行顺序 1)有静态代码,先执行父类静态代码,再执行子类静态代码; 2)有非静态代码,先执行父类非静态代码,父类构造器,再执行子类非静态代码,子类构造器
  • java静态块的作用

    2018-12-26 15:44:32
    (一)java 静态代码 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的...
  • 主要介绍了java 代码静态代码加载顺序的相关资料,需要的朋友可以参考下
  • Java 静态代码和非静态代码

    万次阅读 2016-08-10 21:09:42
    参考:http://uule.iteye.com/blog/1558891Java中的静态代码是在虚拟机加载类的时候,就执行的,而且只执行一次。如果static代码有多个,JVM将按照它们在类中出现的先后顺序依次执行它们,每个代码只会被执行...
  • Java静态代码、非静态代码、构造函数的简单的java代码
  • java基础---静态变量、静态块、非静态块、构造函数及静态方法总结及一点儿想法
  • java 静态代码

    千次阅读 2010-05-27 10:17:00
    (一)java 静态代码 静态方法区别 一般情况下,如果有些代码必须在项目启动的时候就执行的时候,需要使用静态代码,这种代码是主动执行的;需要在项目启动的时候就初始化,在不创建对象的情况下,其他程序来调用的...
  • 所谓的代码是指使用“{}”括起来的一段代码,根据位置不同,代码可以分为构造代码、构造函数、静态代码静态代码:用staitc声明,jvm加载类时执行,仅执行一次 构造代码:类中直接用 {} 定义,每一...
  • 1.普通块方法体内部由大括号{}括起,执行...3.静态块(在此借鉴https://blog.csdn.net/qq_27093465/article/details/75339803)在类的内部使用,形式为static{},静态块一般用于初始化类,为类的属性初始化,每个静...
  • java 静态代码 静态方法

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

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 350,366
精华内容 140,146
关键字:

java静态块

java 订阅