Java类初始化顺序经典实例

一、阿里巴巴笔试题:

 1 public class T  implements Cloneable {
 2     public static int k = 0;
 3     public static T t1 = new T("t1");
 4     public static T t2 = new T("t2");
 5     public static int i = print("i");
 6     public static int n = 99;
 7
 8     public int j = print("j");
 9
10     {
11         print("构造块");
12     }
13
14     static {
15         print("静态块");
16     }
17
18     public T(String str) {
19         System.out.println((++k) + ":" + str + "    i=" + i + "  n=" + n);
20         ++n;
21         ++i;
22     }
23
24     public static int print(String str) {
25         System.out.println((++k) + ":" + str + "   i=" + i + "   n=" + n);
26         ++n;
27         return ++i;
28     }
29
30     public static void main(String[] args) {
31
32     }
33 }

二、加载过程分析:

执行main时,先加载所在类,声明静态变量,并初始化静态变量执行静态代码块(按顺序执行)

初始化到t1时,暂停类加载,先实例化,此时k=0,而i,n都未初始化,系统默认值为0
初始化j时,k自增为1,i,n为0,输出“1:j i=0 n=0”,n,i自增为1
执行代码块,输出“2:构造块 i=1 n=1”,n,i自增为2
执行构造函数,输出“3:t1 i=2 n=2”,n,i自增为3

初始化到t2时,暂停类加载,先实例化,此时k=3,i,n都还未初始化,但已自增为3
初始化j时,k自增为4,i,n未初始化为3,输出“4:j i=3 n=3”,n,i自增为4
执行代码块,输出“5:构造块 i=4 n=4”,n,i自增为5
执行构造函数,输出“6:t2 i=5 n=5”,n,i自增为6

初始化i,输出“7:i i=6 n=6”,n,i自增为7,返回自增后的i赋值给i
初始化n,赋值99
执行静态块,输出“8:静态块 i=7 n=99”,i自增为8,n自增为100

完成类加载

三、涉及知识点:
1.类加载过程:
加载某类前先加载其父类
加载某类时,先声明静态成员变量,初始化为默认值,再初始化静态成员变量执行静态代码块
初始化静态成员变量执行静态代码块时,是按顺序执行(初始化静态成员变量的本质就是静态代码块)

2.实例化过程:
对某类实例化前,先对其父类进行实例化
实例化某类时,先声明成员变量,初始化为默认值,再初始化成员变量执行代码块
初始化成员变量执行代码块时,是按顺序执行

3.在某类加载过程中调用了本类实例化过程(如new了本类对象),则会暂停类加载过程先执行实例化过程,执行完毕再回到类加载过程

4.类的主动使用与被动使用:
主动使用例子:
1):最为常用的new一个类的实例对象
2):直接调用类的静态方法。
3):操作该类或接口中声明的非编译期常量静态字段
4):反射调用一个类的方法。
5):初始化一个类的子类的时候,父类也相当于被程序主动调用了
(如果调用子类的静态变量是从父类继承过来并没有复写的,那么也就相当于只用到了父类的东东,和子类无关,
所以这个时候子类不需要进行类初始化)。
6):直接运行一个main函数入口的类。

所有的JVM实现,在首次主动使用某类的时候才会加载该类。

被动使用例子:
7):子类调用父类的静态变量,子类不会被初始化。只有父类被初始化。对于静态字段,只有直接定义这个字段的类才会被初始化.
8):通过数组定义来引用类,不会触发类的初始化,如SubClass[] sca = new SubClass[10];
9):访问类的编译期常量,不会初始化类

5.编译期常量:
写到类常量池中的类型是有限的:String和几个基本类型
String值为null时,也不会写到类常量池中
使用new String("xx")创建字符串时,得到的字符串不是类常量池中的

6.对于通过new产生一个字符串(假设为 ”china” )时,会先去常量池中查找是否已经有了 ”china” 对象,
如果没有则在常量池中创建一个此字符串对象,然后堆中再创建一个常量池中此 ”china” 对象的拷贝对象。

7.类成员变量才会有默认的初始值
byte:0(8位)
short:0(16位)
int:0(32位)
long:0L(64位)
char:\u0000(16位),代表NULL
float:0.0F(32位)
double:0.0(64位)
boolean: flase

8.局部变量声明以后,Java 虚拟机不会自动的为它初始化为默认值。
因此对于局部变量,必须先经过显示的初始化,才能使用它。
如果编译器确认一个局部变量在使用之前可能没有被初始化,编译器将报错。

9.数组和String字符串都不是基本数据类型,它们被当作类来处理,是引用数据类型。
引用数据类型的默认初始值都是null

时间: 2024-11-06 16:48:21

Java类初始化顺序经典实例的相关文章

java类初始化顺序

java类初始化顺序 执行顺序如下: 没有继承其他类时: 静态变量 静态初始化块 变量 初始化块 构造器 继承其他类时: 父类--静态变量 父类--静态初始化块 子类--静态变量 子类--静态初始化块 父类--变量 父类--初始化块 父类--构造器 子类--变量 子类--初始化块 子类--构造器 执行顺序图:

静态代码块、构造代码块、构造函数以及Java类初始化顺序

静态代码块:用staitc声明,jvm加载类时执行,仅执行一次构造代码块:类中直接用{}定义,每一次创建对象时执行.执行顺序优先级:静态块,main(),构造块,构造方法. 构造函数 public HelloA(){//构造函数 } 关于构造函数,以下几点要注意:1.对象一建立,就会调用与之相应的构造函数,也就是说,不建立对象,构造函数时不会运行的.2.构造函数的作用是用于给对象进行初始化.3.一个对象建立,构造函数只运行一次,而一般方法可以被该对象调用多次. 构造代码块 {//构造代码块 }

Android(java)学习笔记136:Java类初始化顺序

Java类中初试化的顺序: 由此得出Java普通类初始化顺序结论: 静态变量 静态初始化块 变量 初始化块 构造器 由此得出Java继承类初始化顺序结论: 1 .继承体系的所有静态成员初始化(先父类,后子类) 2 .父类初始化完成(普通成员的初始化-->构造函数的调用) 3 .子类初始化(普通成员-->构造函数) Java初始化顺序如图: 代码演示: class Sample { Sample(String s) { System.out.println(s); } Sample() { Sy

转!!关于java类初始化顺序

原文地址:http://www.cnblogs.com/luckygxf/p/4796955.html 1.没有继承 静态变量->静态初始化块->变量->变量初始化块->构造方法 2.有继承的情况 父类静态变量->父类静态初始化块->子类静态变量->子类静态变量初始化块->父类变量初始化->父类变量初始化块->父类构造方法->子类变量初始化->子类变量初始化块->子类构造方法 --------------------------

Java类初始化顺序问题

main -> (静态变量.静态代码块) ->main函数体 -> (类变量.初始化块.实例化引用的类) -> 构造函数 初始化块与实例化引用的类 的调用顺序 按程序的编写上下顺序执行. 1.begin 2.public static XXX xx; 3.static{} 4.public XXX XX; 5.{} 6.new 7.构造 8.done;

Java 类初始化顺序

总的来说: 父类静态代码块->子类静态代码块->子类main()方法->父类构造块->父类构造方法->子类构造块->子类构造方法 注意,就算是静态的方法也需要调用才能使用,初始化只涉及到属性和构造块.构造方法,不涉及到一般的方法. package com.tonyluis; class superClass { public superClass() { System.out.println("构造方法"); } { System.out.print

从Java类初始化,来看代码优化

Java类初始化顺序可能引起的bug 最近编程中遇到的问题, 类的成员初始化过程大家都很了解,都是基础知识,但是有些地方很微妙,重新学习 下,来提高代码质量. 先描述下遇到的场景: 子类构造器中调用super(),然后在父类构造器中调用子类有@overwrite的方法,子类在overwrite的方法中对自己成 员赋值,log输出成功赋值,在子类new完,log打印发现部分成员变量值丢失了. 打印log发现list数据丢失了,int值还在,如下: 看了半天感觉还是很奇怪,有点不相信代码的感觉,最后

Java变量、Java对象初始化顺序

局部变量与成员变量: 局部变量分为: 行参:在方法签名中定义的局部变量,随方法的结束而凋亡. 方法内的局部变量:必须在方法内对其显示初始化,从初始化后开始生效,随方法的结束而凋亡. 代码块内的局部变量:必须在代码块内对其显示初始化,从初始化后开始生效,随代码块的结束而凋亡. 成员变量: 静态属性:类加载时初始化,随着类的存在而存在: 非静态属性:随着实例的属性存在而存在: 关于他两的区别: 1.局部变量不可以加static: 2.局部变量不可以加public.protected.private:

Java 对象初始化顺序 执行顺序

先看一道Java面试题: 求这段程序的输出. 解答此题关键在于理解和掌握类的加载过程以及子类继承父类后,重写方法的调用问题: 从程序的执行顺序去解答: 1.编译:当这个类被编译通知后,会在相应的目录下生成两个.class 文件.一个是 Base.class,另外一个就是Base$Sub.class.这个时候类加载器将这两个.class  文件加载到内存 2.Base base= new Sub(): 声明父类变量base对子类的引用,JAVA类加载器将Base,Sub类加载到JVM(Java虚拟