(转载+总结) Java初始化顺序
来源:互联网 发布:无线通信网络安全技术 编辑:程序博客网 时间:2024/06/11 17:19
1.类的初始化(initialization class & interface)
2.对象的创建(creation of new class instances)。
因为类的初始化其实是类加载(loading of classes)的最后一步,所以很多书中把它归结为“对象的创建”的第一步。其实只是看问题的角度不同而已。为了更清楚的理解,这里还是分开来。
顺序:
类的加载肯定是第一步的,所以类的初始化在前。大体的初始化顺序是:
类初始化 -> 子类构造函数 -> 父类构造函数 -> 实例化成员变量 -> 继续执行子类构造函数的语句。
1.类的初始化(Initialization classes and interfaces),其实很简单,具体来说有:
(a)初始化类(initialization of class),是指初始化static field 和执行static初始化块。
例如:
class Super {
static String s = “initialization static field”; //初始化static field,其中“= “initialization static field” ”又叫做static field initializer
// static初始化块,又叫做static initializer,或 static initialization block
static {
System.out.println(“This is static initializer”);
}
}
btw,有些书上提到static initializer 和 static field initializer 的概念,与之对应的还有 instance initializer 和 instance variable initializer。例子中的注释已经解释了其含义。
*注意*
--initialization classes 时,该class的superclass 将首先被初始化,但其实现的interface则不会。
--initialization classes 时,该class的superclass,以及superlcass的superclass 会首先被递归地初始化,一直到java.lang.Object为止。但initialiazation interface的时候,却不需如此,只会初始化该interface本身。
--对于由引用类变量(class field)所引发的初始化,只会初始化真正定义该field的class。
--如果一个static field是编译时常量(compile-time constant),则对它的引用不会引起定义它的类的初始化。
为了帮助理解最后两点,请试试看下面的例子:
这三个类都在 com.loader 包里。
package com.loader;public class Initialization {public static void main(String[] args) {//System.out.println("Super.s: "+Super.s); System.out.println("Sub.x:"+Sub.x); // Won't cause initialization of Sub, because x is declared by S, not Sub. // 不会引起Sub类的初始化,因为x是定义在Super类中的 System.out.println("-------------------------"); System.out.println("Sub.y:"+Sub.y); // Won't cause initialization of Sub, because y is constant. // 不会引起Sub类的初始化,因为y是常量 //System.out.println("Sub.s1:"+Sub.s1); System.out.println("-------------------------"); System.out.println("Sub.z:"+(Sub.z = 2004)); // Will cause initialization of Sub class//将会引起Sub的初始化}}
Super.java
package com.loader;class Super { static String s = "Super.java initialization static field"; //初始化static field,其中“= “initialization static field” ”又叫做static field initializer static int x = 2006; // static初始化块,又叫做static initializer,或 static initialization block static { System.out.println("Super.java This is static initializer"); }}
Sub.java
package com.loader;public class Sub extends Super{static final int y = 2005;static String s1 = "Sub.java initialization static field s1"; static int z; static { System.out.println("Sub.java Initialization Sub"); }}
执行结果如下:
Super.java This is static initializer (执行 Super.java static { } static 初始代码块 )
Sub.x: 2006 (// 不会引起Sub类的初始化,因为x是定义在Super类中的,从没有打印出 “Sub.java Initialization Sub” 这句话,打印了这句话代表sub 历经初始化了)— 回答了这句话 --对于由引用类变量(class field)所引发的初始化,只会初始化真正定义该field的class。
-------------------------
Sub.y: 2005 (// 不会引起Sub类的初始化,因为y是常量.)— 回答了这句话 --如果一个static field是编译时常量(compile-time constant),则对它的引用不会引起定义它的类的初始化。
-------------------------
Sub.java Initialization Sub (引用了Sub.z 所以Sub 类初始化了,“Sub.java Initialization Sub” 这句话已经打印出了。)
Sub.z: 2004
如果我们把 //System.out.println("Super.s: "+Super.s); 的注释去掉(位于Initialization.java 第6行)。执行结果如下:
Super.java This is static initializer
Super.s: Super.java initialization static field
Sub.x: 2006
-------------------------
Sub.y: 2005
-------------------------
Sub.java Initialization Sub
Sub.z: 2004
(This is static initializer 只打印一次,应该类加载初始化只需一次所以 执行Sub.x 时不需重新加载了所以不再打印了This is static initializer)。
如果我们把 //System.out.println("Sub.s1: "+Sub.s1); 的注释去掉 , //System.out.println("Super.s: "+Super.s); 还是加上注释(位于Initialization.java 第12行)。执行结果如下:
Super.java This is static initializer
Sub.x: 2006
-------------------------
Sub.y: 2005
Sub.java Initialization Sub
Sub.s1: Sub.java initialization static field s1
-------------------------
Sub.z: 2004
可以看出 System.out.println("Sub.s1: "+Sub.s1); 触发了 Sub 类的初始化。
Sub.s1 不是常量。 static String s1 = "Sub.java initialization static field s1"; 只是把 Sub.s1 指向了 字符串常量“Sub.java initialization static field s1” 。
只有加了final 的才能当做类得常量。所以要触发Sub 类的初始化。
2。对象的创建(creation of new class instances),稍微有点烦琐,具体的步骤如下
(a) 所有的成员变量—包括该类,及它的父类中的成员变量--被分配内存空间,并赋予默认值。(Btw,这里是第一次初始化成员变量)
(b) 为所调用的构造函数初始化其参数变量。(如果有参数)
(c) 如果在构造函数中用this 调用了同类中的其他构造函数,则按照步骤(b)~(f)去处理被调用到的构造函数。
(d) 如果在构造函数中用super调用了其父类的构造函数,则按照步骤(b)~(f)去处理被调用到的父类构造函数。
(e) 按照书写顺序,执行instance initializer 和 instance variable initializer来初始化成员变量。(Btw,这里是第二次初始化成员变量)
(f) 按照书写顺序,执行constructor的其余部分。
*注意*
成员变量其实都被初始化2次,第一次是赋予默认值,第二次才是你想要设定的值。
最后看一个例子:
这个例子的4个类都在com.initialization 包里。
package com.initialization;public class InitializationOrder { public static void main(String[] args) { Subclass sb = new Subclass(); }}
package com.initialization;public interface Interface {static Super su = new Super(0);}
package com.initialization;public class Super { static { System.out.println("Super.java static chunk "); } Super(int i){ System.out.println("Super.java Super(inti )constructor "+i); }}
package com.initialization;public class Subclass extends Super implements Interface {static { System.out.println("Subclass.java static chunk");} Super su = new Super(4);static Super su1=new Super(100);int b=5;Subclass() { super(3); //执行完super(3) su还是等于su=null 和b=0,再开始执行su = new Super(4); 这语句。可以通过调试查看程序运行过程 su=new Super(5); System.out.println("Subclass.java Subclass class member b: "+b); System.out.println("End Subclass.java Subclass() Constructor");}Subclass(int i){super(8);System.out.print("Subclass.java Subclass(int i)"+i);}}执行结果如下
Super.java static chunk
Subclass.java static chunk
Super.java Super(inti )constructor 100 (从前3个打印语句看出,首先进行类的初始化。执行static初始化块,再初始化static field。static Super su1=new Super(100);)
Super.java Super(inti )constructor 3 (执行构造函数的super();)
Super.java Super(inti )constructor 4 (书写顺序,执行instance initializer 和 instance variable initializer来初始化成员变量。 在此之前各变量是默认指)
(下面执行构造函数其余部分了)
Super.java Super(inti )constructor 5
Subclass.java Subclass class member b: 5
End Subclass.java Subclass() Constructor 。
稍微解释一下:
首先,Java虚拟机要执行InitializationOrder类中的static 方法main(),这引起了类的初始化。
开始初始化InitializationOrder类。具体的步骤略去不说。
接着,InitializationOrder类初始化完毕后,开始执行main()方法。
语句Subclass sb = new Subclass()将创建一个Subclass对象。加载类Subclass后对其进行类初始化,但因为Subclass有一个父类Super,
所以先初始化Super类,初始化块System.out.println("Super.java static chunk ");被执行,打印输出1;
第三,Super初始化完毕后,开始初始化Subclass类。 System.out.println("Subclass.java static chunk");被执行,
第四,至此,类的加载工作全部完成。开始进入创建Subclass的对象过程。先为Subclass类和其父类Super类分配内存空间,这时Super su 被附值为null;
第五,执行构造函数Subclass()时,super(3)被执行。如前面(d)所说,Super类的构造函数Super(int i){….}被调用,并按照步骤(b)~(f)来处理。因此,递归调用Super类的父类Object类的构造函数,并按照步骤(b)~(f)来初始化Object类,不过没有任何输入结果。最后打印输出Super.java Super(inti )constructor 3“;
第六,如前面(e)所说,初始化成员变量su,其结果是打印输出”Super.java Super(inti )constructor 4“;
第七,如前面(f)所说,执行new Super(5),并打印输出”Super.java Super(inti )constructor 5“;
最后,Subclass虽然实现了接口Interface,但是初始化它的时候并不会引起接口的初始化(也许这也是java 的interface 中不定义变量的原因之一),所以接口Interface中的static Super su = new Super(0)自始至终都没有被执行到。
想法:
关于下面几点点想法: (还要仔细研究欢迎大师指点指点。)
--对于由引用类变量(class field)所引发的初始化,只会初始化真正定义该field的class。
--如果一个static field是编译时常量(compile-time constant),则对它的引用不会引起定义它的类的初始化。
-- System.out.println("Sub.x: "+Sub.x); // 不会引起Sub类的初始化,因为x是定义在Super类中的。
为什么是这样的机制,我想跟java 的内存机制有关。
常量和静态变量不属于类得内存区域。
下图是java 执行过程和内存布局图:
堆区:
1.存储的全部是对象,每个对象都包含一个与之对应的class的信息。(class的目的是得到操作指令)
2.jvm只有一个堆区(heap)被所有线程共享,堆中不存放基本类型和对象引用,只存放对象本身
栈区:
1.每个线程包含一个栈区,栈中只保存基础数据类型的对象和自定义对象的引用(不是对象),对象都存放在堆区中
2.每个栈中的数据(原始类型和对象引用)都是私有的,其他栈不能访问。
3.栈分为3个部分:基本类型变量区、执行环境上下文、操作指令区(存放操作指令)。
数据区
1.又叫静态区,跟堆一样,被所有的线程共享。方法区包含所有的class和static变量。
方法区:
1.方法区中包含的都是在整个程序中永远唯一的元素,如class,static变量。
- (转载+总结) Java初始化顺序
- Java初始化顺序总结
- 【转载】java继承 初始化顺序
- java类初始化顺序总结
- java 初始化顺序相关总结
- Java变量初始化顺序总结
- 转载:c++ 初始化顺序
- Java中类的初始化顺序总结
- Java&&(面试题)初始化顺序总结
- Java 基础总结--初始化顺序1
- Java初始化总结【6、涉及到继承时 初始化顺序!!!!!】
- Java创建对象的初始化顺序(转载)
- java-java初始化顺序
- Java基础总结之类与对象的初始化顺序
- Java面试题(类初始化顺序总结)
- Java初始化顺序
- JAVA 初始化顺序
- JAVA初始化顺序
- 学习ARM的心得
- 修改Windows的默认文件查看方式
- makefile自动生成
- ZJNU 1889 太空行走
- Using GNU C __attribute__ (ZZ)
- (转载+总结) Java初始化顺序
- 嵌入式分区问题,无法挂载文件系统
- Android游戏开发之切换游戏场景特效的实现 (十九)
- java面试
- 工作第一周
- 学习linux的一些精华贴和视频 我归纳了些 一下是连接 !
- RTP payload type
- iar used for multiple files 问题的解决
- Java基础篇笔记(一) ---变量的命名规则