精华内容
下载资源
问答
  • Java类初始化顺序

    2016-01-22 00:04:41
    Java类初始化顺序,是先静态对象,而后是非静态对象。加载器加载class文件时,初始化静态对象。new操作符时,初始化非静态对象。在的内部,变量定义的先后决定了初始化顺序。即使变量定义散布于方法定义之间...

    Java程序在它运行之前,并非完全加载,其各个部分是在必需时才加载。Java类的初始化顺序,是先静态对象,而后是非静态对象。类加载器加载class文件时,初始化静态对象。new操作符时,初始化非静态对象。

    在类的内部,变量定义的先后决定了初始化的顺序。即使变量定义散布于方法定义之间,它们仍旧会在任何方法(包括构造方法)被调用之前得到初始化。


    1.无继承类初始化

    public class Client {
    
    
        public static class Person {
            public Person(String str) {
                System.out.println(str);
            }
        }
    
        public static class Test {
    
            //静态成员变量 A
            public static Person sPersonA = new Person("A 静态成员变量初始化");
    
            //静态初始化代码块 B
            static {
                System.out.println("B 静态初始化块");
            }
    
            //成员变量 C
            public Person mPersonC = new Person("C 成员变量初始化");
    
            //初始化代码 D
            {
                System.out.println("D 初始化代码块");
            }
    
            //构造函数 E
            public Test() {
                System.out.println("E 构造函数");
            }
    
    
            //静态成员变量 F
            public static Person sPersonF = new Person("F 静态成员变量初始化");
    
            //静态初始化代码块 G
            static {
                System.out.println("G 静态初始化块");
            }
    
            //成员变量 H
            public Person mPersonH = new Person("H 成员变量初始化");
    
            //初始化代码 I
            {
                System.out.println("I 初始化代码块");
            }
    
    
        }
    
        public static void main(String[] args) {
            Test test = new Test();
        }
    
        }
    

    运行结果如下:

    A 静态成员变量初始化
    B 静态初始化块
    F 静态成员变量初始化
    G 静态初始化块
    C 成员变量初始化
    D 初始化代码块
    H 成员变量初始化
    I 初始化代码块
    E 构造函数

    由此可以得出以下结论:

    初始化顺序: 静态变量/静态代码块 -> 成员变量/代码块 -> 构造函数
    其中,静态变量与静态代码块,成员变量与代码块的初始化顺序只取决于定义顺序。

    Created with Raphaël 2.1.0Start静态变量/静态代码块成员变量/代码块构造函数End

    2. 子类初始化顺序

    创建一个TestSub类继承Test类,

    public static class TestSub extends Test {
    
        //静态成员变量 a
        public static Person sPersonA = new Person("a 静态成员变量初始化");
    
        //静态初始化代码块 b
        static {
            System.out.println("b 静态初始化块");
        }
    
        //成员变量 c
        public Person mPersonC = new Person("c 成员变量初始化");
    
        //初始化代码 d
        {
            System.out.println("d 初始化代码块");
        }
    
        //构造函数 e
        public TestSub() {
            System.out.println("e 构造函数");
        }
    
    
        //静态成员变量 f
        public static Person sPersonF = new Person("f 静态成员变量初始化");
    
        //静态初始化代码块 g
        static {
            System.out.println("g 静态初始化块");
        }
    
        //成员变量 h
        public Person mPersonH = new Person("h 成员变量初始化");
    
        //初始化代码 i
        {
            System.out.println("i 初始化代码块");
        }
    
    }
    
    
    public static void main(String[] args) {
        //Test test = new Test();
        TestSub sub = new TestSub();
    }

    运行结果如下:

    A 静态成员变量初始化
    B 静态初始化块
    F 静态成员变量初始化
    G 静态初始化块
    a 静态成员变量初始化
    b 静态初始化块
    f 静态成员变量初始化
    g 静态初始化块
    C 成员变量初始化
    D 初始化代码块
    H 成员变量初始化
    I 初始化代码块
    E 构造函数
    c 成员变量初始化
    d 初始化代码块
    h 成员变量初始化
    i 初始化代码块
    e 构造函数

    由此可以得出以下结论:

    子类初始化顺序:
    父类静态变量/父类静态方法块 -> 子类静态变量/子类静态方法块 -> 父类成员变量/方法块 -> 父类构造函数 -> 子类成员变量/方法块 -> 子类构造函数

    Created with Raphaël 2.1.0Start父类静态变量/父类静态方法块子类静态变量/子类静态方法块父类成员变量/方法块父类构造函数子类成员变量/方法块子类构造函数End
    展开全文
  • Java 类初始化顺序

    2016-06-07 16:24:50
    变量的初始化过程:首先将静态变量定义时的初始化语句放到静态初始化块的开始部分,然后从该的原始祖先开始依次向下执行每个的静态初始化块 对象的初始化发生在创建对象时 对象的初始化过程会先将的定义...

    初始化时机

    初始化分为类变量的初始化与对象的初始化两个相对独立的过程

    • 类变量的初始化在程序中第一次用到该类时
      类变量的初始化过程:首先将静态变量定义时的初始化语句放到静态初始化块的开始部分,然后从该类的原始祖先开始依次向下执行每个类的静态初始化块
    • 对象的初始化发生在创建对象时
      对象的初始化过程会先将类的定义成员变量时的初始化语句及非静态初始化块都放到构造函数的开始部分,然后从该类的原始祖先开始依次向下执行每个类的构造函数

    初始化谜题

    类的定义过程中创建对象

    • 在main中遇到Demo,执行类变量demo初始化,new Demo()引起对象初始化过程
    • 对象初始化过程首先将 int y = 1 放到Demo构造函数开始部分,所以结果中 y =1
    • 但是注意static int x =1句并没有被执行,因此此时 x =0
    • 类变量demo初始化完成,然后执行类变量 x的初始化 x=1
    • 最后输出Demo.x,此时x已初始化完成, 所以 x = 1
    public class Demo {
        static Demo demo = new Demo();
        static int x = 1;
        int y = 1;
        Demo() {
            System.out.println(x);
            System.out.println(y);
        }
        public static void main(String[] args) {
            System.out.println(Demo.x);
        }
    } //结果:0    1    1 

    循环初始化

    • new Demo()句引起执行对象初始化
    • 对象初始化首先会将 Demo demo = new Demo()句置于构造函数的开始部分
    • 在执行移入构造函数内部的Demo demo = new Demo()句时引起死循环调用构造函数,从而引起StackOverflowError
    public class Demo {
        Demo demo = new Demo();
        Demo() {
        }
        public static void main(String[] args) {
            System.out.println(new Demo());
        }
    }  // 结果:StackOverflowError
    展开全文
  • java类初始化顺序

    2015-03-05 00:05:48
    首先静态初始化;如,static User = new User(); 其次,自动初始化默认值;如,private int a; 再次,执行定义处的初始化;如,private int a = 4; 最后,构造函数初始化。如,public User(){

    具体参见《java编程思想,4th edition》p189.

    当用到类的静态方法或静态域时,会加载类的.class文件:

    首先静态初始化;如,static User = new User();

    其次,自动初始化默认值;如,private int a;

    再次,执行定义处的初始化;如,private int a = 4;

    最后,构造函数初始化。如,

    public User(){
           a = 5;
    }

    展开全文
  • JAVA类初始化过程

    2019-03-20 11:17:16
    初始化过程: 一个要创建实例需要先加载并初始化该(main方法所在的需要先加载和初始化 ) 一个子类要初始化需要先初始化父类 一个初始化就是执行<clinit>()方法 <clinit>()方法由...

    输入结果为

    类的初始化过程: 

    一个类要创建实例需要先加载并初始化该类( main方法所在的类需要先加载和初始化 )

    一个子类要初始化需要先初始化父类

    一个类初始化就是执行<clinit>()方法

    1. <clinit>()方法由静态类变量显示赋值代码和静态代码块组成
    2.  类变量显示赋值代码和静态代码块代码从上到下顺序执行
    3. <clinit>()方法只执行一次

     

    实例初始化过程:

    a,实例初始化就是执行<init>()方法

    1. <init>()方法可能重载有多个,有几个构造器就有几个<init>方法
    2. <init>()方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成
    3. 非静态实例变量显示赋值代码和非静态代码块代码从上到下顺序执行,而对应构造器的代码最后执行
    4. 每次创建实例对象,调用对应构造器,执行的就是对应的<init>方法
    5. <init>方法的首行是super()或super(实参列表),即对应父类的<init>方法

    方法的重写Override :

    哪些方法不可以被重写

    1. final方法
    2. 静态方法
    3. private等子类中不可见方法

    对象的多态性

    1. 子类如果重写了父类的方法,通过子类对象调用的一定是子类重写过的代码
    2. 非静态方法默认的调用对象是this
    3. this对象在构造器或者说<init>方法中就是正在创建的对象
    展开全文
  • Java类初始化过程

    2016-10-31 10:09:19
    Java类的初始化有以下几个原则: 1.先父类,后子类(因为...在初始化过程中,随着虚拟机加载的class文件,static变量会首先得到初始化,初始化的时候按照:先初始化父类的静态变量,在初始化子的静态变量。同一
  • JAVA类初始化顺序总结

    万次阅读 2018-09-27 23:16:24
    首先来看下,当一个从main入口方法,对于静态变量、静态初始化块、变量、初始化块、构造器,它们的初始化顺序: public class ClassLoadTest { private static User user = new User(); static { System.err....
  • JAVA 类初始化顺序

    千次阅读 2009-03-08 18:19:00
    1,先初始化静态成员变量,因为客户程序可能不构造你的实例而access静态成员变量. 2,父类的构造函数,因为子类可能要access父类的东西.比如:在父类里加上 protected String str = null;在父类构造函数()里加上 str = ...
  • Java类初始化顺序: class Super { { System.out.println("super non-static initalization before"); } static { System.out.println("super static initalization before"); } public Super() { ...
  • Java类初始化顺序规律

    2016-07-12 21:08:21
    静态构造块、静态属性按出现在定义里面的先后顺序初始化,同理非静态的也是一样的,只是静态的只在加载字节码是执行一次,不管你new多少次,非静态会在new多少次就执行多少次 规律三、java中的只有在被用到的...
  • Java类初始化顺序分析

    千次阅读 2010-07-27 13:48:00
    近来碰到了Java类初始化顺序的问题(主要是静态部分),故整理在此。因为Java虚拟机部分还没研究完,所以先写一点编程中出现的情况,至于原理和为什么以后再补充。首先提一下:1、(静态)变量 虚拟机对(静态)...
  • 正常来说一个初始化过程应该是: 1、全局静态变量 2、静态代码块 3、全局变量 4、代码块 5、构造器 有这么一个例子: ``` public class LoadTest { //全局静态变量 static int staticI = 10; //全局变量 ...
  • Java类初始化顺序的一些理解

    千次阅读 2019-04-10 23:21:21
    静态代码块:用staitc声明,jvm加载时执行,仅执行一次 构造代码块:中直接用{}定义,每一次创建对象时执行。 执行顺序优先级:(静态块| 静态变量) , main(), (构造块|成员变量) , 构造方法。 括号内的内容...
  • 文章目录一、构造函数二、构造代码块三、静态代码块四、Java类初始化顺序①、对于一个的情况②、对于继承情况分析 静态代码块:用staitc声明,jvm加载时执行,仅执行一次 构造代码块:中直接用{}定义,每...
  • java类初始化顺序总结

    2011-12-06 12:57:51
    JAVA类首次装入时,会对静态成员变量、静态初始化块、静态方法进行一次初始化,静态成员变量和静态初始化块级别相同,静态方法如果没有调用则不会执行。另外,在实例化对象的时候非静态成员变量和非静态初始化块级别...
  • 最近发现微信群里面有些群友在讨论初始化顺序,如的静态变量、成员变量、静态代码块、非静态代码块、构造器,及继承父类时,它们的初始化顺序都是怎样的,下面我通过例子来说明这个情况,以免被人误导。...
  • 前言:最近写代码的时候经常见到见到static代码块,不由对static的执行时间产生了兴趣,进而对类初始化顺序产生了兴趣. 从编译到执行的过程: 在使用ClassLoader将字节码转换为JVM中的Class&lt;Robot&gt;...
  • java类初始化顺序-阿里笔试题

    千次阅读 2013-09-23 12:20:11
     初始化一个(main方法执行之前),主要是对静态成员变量的初始化过程分为两步:1) 按照静态成员变量的定义顺序内部声明成员变量;2)按中成员变量的初始化顺序初始化。  本例中,先声明成员变量k,...
  • 首先用文字简单描述一下Java 初始化顺序(此处引用 Core Java Volume I 中的译文) 规则1:在第一次加载的时候,将会进行静态域的初始化: 1. 将所有的静态数据域初始化为默认值(0、false 和 null) 2. ...
  • 静态代码块:用staitc声明,jvm加载时执行,仅执行一次 构造代码块:中直接用{}定义,每一次创建对象时执行。 执行顺序优先级:静态块,main(),构造块,构造方法。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 715,261
精华内容 286,104
关键字:

java类的初始化过程

java 订阅