- <font size="3">class ClassA{
- static { //静态代码块
- System.out.println("In ClassA Static");
- }
- public ClassA(){
- System.out.println("ClassA()");
- }
- }
- class ClassB{
- static { //静态代码块
- System.out.println("In ClassB Static");
- }
- public ClassB(){
- System.out.println("ClassB()");
- }
- }
- class ClassC extends ClassB{
- static{
- System.out.println("In ClassC Static");
- }
- public ClassC(){
- System.out.println("ClassC()");
- }
- }
- class MyClass {
- static ClassA ca = new ClassA();
- ClassC cc = new ClassC();
- static{
- System.out.println("In MyClass Static");
- }
- public MyClass(){
- System.out.println("MyClass()");
- }
- }
- public class TestMain{
- public static void main(String args[]){
- MyClass mc1 = new MyClass(); //
- MyClass mc2 = new MyClass();
- System.out.println(mc1.cc == mc2.cc);
- System.out.println(mc1.ca == mc2.ca);
- }
- } </font>
写出这个程序运行的结果。
该题需要创建两个MyClass 对象。
一般而言，创建对象的过程如下：
1) 分配空间
2) 递归构造父类对象
3) 初始化本类属性
4) 调用本类构造方法
如果某个类是JVM 运行中第一次遇到，则会进行类加载的动作。类加载会初始化该类
的静态属性，并执行该类的静态初始化代码块。
1) 加载MyClass 类，并初始化其静态属性
2) 为MyClass 分配空间
3) 递归构造MyClass 的父类对象。
4) 初始化MyClass 属性
5) 调用MyClass 的构造方法。
6) 为MyClass 分配空间
7) 递归构造MyClass 的父类对象
8) 初始化MyClass 属性
9) 调用MyClass 的构造方法。
经过9 个步骤，两个对象创建完毕。
其中，在第1 步时，类加载时会初始化其静态属性，之后会执行静态初始化代码块，因
此对第1 步进行细分：
1.1 初始化ca 属性
1.2 执行MyClass 的静态初始化代码块。
在1.1 执行时，初始化ca 属性会创建ClassA 对象。由于这是第一次在程序中用到ClassA
对象，因此会执行对ClassA 对象的类加载。即：1.1 步可以细分为以下步骤：
1.1.1 加载ClassA 类
1.1.2 创建ClassA 对象
在初始化MyClass 属性时，需要创建ClassC 对象。而程序执行到第4 步时是第一次遇
到ClassC 类型的对象，因此会执行ClassC 的类加载。因此，对第4 步和第8 步进行细化：
第4 步：初始化MyClass 属性：
4.1 加载ClassC
4.2 为ClassC 分配空间
4.3 递归构造ClassC 的父类对象
4.4 初始化ClassC 属性
4.5 调用ClassC 的构造方法
第8 步，初始化MyClass 属性：
8.1 为ClassC 分配空间
8.2 递归构造ClassC 的父类对象
8.3 初始化ClassC 属性
8.4 调用ClassC 的构造方法
对于4.1 而言，为了创建ClassC 对象，必须获取ClassC 类的信息。而获得ClassC 类完
整信息的前提，是获得ClassB 类的信息。由于是第一次遇到ClassB 和ClassC，因此会先加
载ClassB，之后加载ClassC。细分之后，4.1 分为以下两步：
4.1.1 加载ClassB
4.1.2 加载ClassC
完整列出所有步骤如下：
1.1.1 加载ClassA 类 输出In ClassA Static
1.1.2 创建ClassA 对象 输出ClassA()
1.2 执行MyClass 的静态初始化代码块 输出In Static MyClass
2 分配MyClass 的空间 无输出
3 递归构造MyClass 的父类对象 无输出
4.1.1 加载ClassB 输出 In ClassB Static
4.1.2 加载ClassC 输出In ClassC Static
4.2 分配ClassC 的空间 无输出
4.3 构造ClassC 的父类对象(ClassB) 输出ClassB()
4.4 初始化ClassC 属性 无输出
4.5 调用ClassC 的构造方法 输出ClassC()
5 调用MyClass 的构造方法 输出MyClass()
6 为MyClass 分配空间 无输出
7 递归构造MyClass 的父类对象 无输出
8.1 为ClassC 分配空间 无输出
8.2 递归构造ClassC 的父类对象 ClassB()
8.3 初始化ClassC 的属性 无输出
8.4 调用ClassC 的构造方法 ClassC()
9 调用MyClass 的构造方法 MyClass()
以上是我的分析可是有一下几点不是太明白:
1.当一个类和他的父类中中同时出现静态代码块,的时候是怎么进行创建对象的?
2.静态的成员是不是所有的都只是加载一次?
我分析的输出结果是:
In ClassA Static
ClassA()
In Static MyClass
In ClassB Static
In ClassC Static
ClassB()
ClassC()
MyClass()
ClassB()
ClassC()
MyClass()
追加提问:
如果将ClassA添加一个父类ClassObject,再将ClassA中的静态代码块
static { //静态代码块
System.out.println("In ClassA Static");
} 改为
static { //静态代码块
Object o;
System.out.println("In ClassA Static");
} 流程是怎么走的呢?
类Object如下
Class Object {
static {
System.out.println("static int Objict");
}
Object (){
Systen.out.println("Object ()");
}
}
就是想加强一下对继承和代码块以及有继承关系的创建对象过程的了解
同时也希望对大家的知识有所巩固
|
|
收藏
淘帖
踩
