大家好,这几天没事做,找了一些笔试题来看,发现有一个自己对于代码块的启动顺序不是很理解,特上来问一问。先上代码先
public class FF extends DD
{
{
System.out.print("1");
}
FF()
{
super(7);
System.out.print("2");
}
static
{
System.out.print("3");
}
public static void main(String[] args)
{
FF f = new FF();
}
}class DD
{
DD(int x)
{
System.out.print("4");
System.out.print(x);
}
static
{
System.out.print("5");
}
{
System.out.print("6");
}
}先把输出的结果写出来吧:5364712我们知道static代码块是在装载代码的时候就放在代码区的,然后寻找静态的main方法(有点罗嗦不说了)无疑问,静态的代码是先执行的,而类FF继承了DD,所以父类的静态代码先执行再执行子类的静态代码,这时会输出:53(应该是样子吧?)由于{}代码块优先级大于构造函数,所以先执行父类的{}代码块,这时输出是:536(这里应该没问题吧?)接下来就不明白了,程序会执行DD的构造函数的代码,怎么会跳到这里来呢?这个父类的构造函数中的参数是怎么传过来的呢?如果说是先执行了子类FF的构造方法,那么根据"{}代码块优先级大于构造函数"这一定义,那么应该会执行FF的{}代码块输出1啊,也就是1在4和7之前啊(也就是536147)这一点不是很明白,希望各位兄弟给小弟讲讲其中的原理。分数我会再加的。
public class FF extends DD
{
{
System.out.print("1");
}
FF()
{
super(7);
System.out.print("2");
}
static
{
System.out.print("3");
}
public static void main(String[] args)
{
FF f = new FF();
}
}class DD
{
DD(int x)
{
System.out.print("4");
System.out.print(x);
}
static
{
System.out.print("5");
}
{
System.out.print("6");
}
}先把输出的结果写出来吧:5364712我们知道static代码块是在装载代码的时候就放在代码区的,然后寻找静态的main方法(有点罗嗦不说了)无疑问,静态的代码是先执行的,而类FF继承了DD,所以父类的静态代码先执行再执行子类的静态代码,这时会输出:53(应该是样子吧?)由于{}代码块优先级大于构造函数,所以先执行父类的{}代码块,这时输出是:536(这里应该没问题吧?)接下来就不明白了,程序会执行DD的构造函数的代码,怎么会跳到这里来呢?这个父类的构造函数中的参数是怎么传过来的呢?如果说是先执行了子类FF的构造方法,那么根据"{}代码块优先级大于构造函数"这一定义,那么应该会执行FF的{}代码块输出1啊,也就是1在4和7之前啊(也就是536147)这一点不是很明白,希望各位兄弟给小弟讲讲其中的原理。分数我会再加的。
解决方案 »
- IE8 中使用eval()函数报错
- 如何实现类似功能?
- 急!prototype和json
- 关于在jsp中循环显示的问题!!!
- 在java中property和attribute区别是什么
- 请给个例子!!!poi jxl怎样导入远程客户机上的Excel文件到服务器数据库
- SSH框架写的东西出现了莫名其妙的问题
- 我用SmartUpload上传文件,有两个问题:
- 各位,怎样实现B/S结构中,在同时刻只能一个用户身份口令登录(同一时间内,相同帐号只能一人用)。谢谢(急)
- 各位大佬,springboot怎么关闭本身的日志功能,用log4j日志
- e3table的显示
- struts2国际化问题,回复者均给分!!
private static int p1 = staticPrintInt("P....初始化父类静态属性", 100);
private int p2 = instancePrintInt("P....初始化父类实例属性", 200);
static{
System.out.println("P....执行父类静态代码段");
} {
System.out.println("P....执行父类非静态代码段");
}
public static int staticPrintInt(String str, int value){
System.out.println(str);
return value;
}
public int instancePrintInt(String str, int value){
System.out.println(str);
return value;
}
public void publicPrintProperty(){
System.out.println("P....Parent public 方法");
System.out.println("P....p1 =" + p1);
System.out.println("P....p2 =" + p2);
} private void privatePrintProperty(){
System.out.println("P....Parent private 方法");
System.out.println("P....p1 =" + p1);
System.out.println("P....p2 =" + p2);
} public Parent(){
System.out.println("P....父类构造器");
publicPrintProperty();
privatePrintProperty();
}
public static void main(String[] args){
Parent p;
System.out.println("========================");
p = new Parent();
}
}执行该类之后,会得到以下输出P....初始化父类静态属性
P....执行父类静态代码段
========================
P....初始化父类实例属性
P....执行父类非静态代码段
P....父类构造器
P....Parent public 方法
P....p1 =100
P....p2 =200
P....Parent private 方法
P....p1 =100
P....p2 =200从上面的输出可以看出,使用直接父类为Object的类创建对象过程是:
a、加载类1、为静态属性分配内存并赋值
2、执行静态代码段b、创建对象1、为实例属性分配内存并赋值
2、执行非静态代码段
3、执行构造器[NextPage]
1、再测试直接父类不是Object的类package com.guandl.thinking;public class Child extends Parent{
private static int c1 = staticPrintInt("C....初始化子类静态属性", 1000);
private int c2 = instancePrintInt("C....初始化子类实例属性", 2000);
static{
System.out.println("C....执行子类静态代码段");
} {
System.out.println("C....执行子类非静态代码段");
}
public void publicPrintProperty(){
System.out.println("C....Child public 方法");
System.out.println("C....c1 =" + c1);
System.out.println("C....c2 =" + c2);
} private void privatePrintProperty(){
System.out.println("C....Child private 方法");
System.out.println("C....c1 =" + c1);
System.out.println("C....c2 =" + c2);
}
public Child(){
System.out.println("C....子类构造器");
publicPrintProperty();
privatePrintProperty();
} public static void main(String[] args){
Child c;
System.out.println("========================");
c = new Child();
}
}执行之后会输入以下结果P....初始化父类静态属性
P....执行父类静态代码段
C....初始化子类静态属性
C....执行子类静态代码段
========================
P....初始化父类实例属性
P....执行父类非静态代码段
P....父类构造器
C....Child public 方法
C....c1 =1000
C....c2 =0
P....Parent private 方法
P....p1 =100
P....p2 =200
C....初始化子类实例属性
C....执行子类非静态代码段
C....子类构造器
C....Child public 方法
C....c1 =1000
C....c2 =2000
C....Child private 方法
C....c1 =1000
C....c2 =2000
从上面的输出可以看出,使用直接父类不是Object的类创建对象过程是:
a、加载类1、为父类静态属性分配内存并赋值
2、执行父类静态代码段
3、为子类静态属性分配内存并赋值
4、执行子类静态代码段b、创建对象
1、为父类实例属性分配内存并赋值
2、执行父类非静态代码段
3、执行父类构造器
5、为子类实例属性分配内存并赋值
6、执行子类非静态代码段
7、执行子类构造器在这个过程里面,我们会注意到两段工作都是先处理父类,然后再处理子类的。也就是子类重复了一遍父类的工作。
这个过程里面可能会遇到一个特殊现象,那就是:
1、子类覆盖了父类中的某个方法。
2、父类构造器中调用到了该方法
3、在子类中,该方法访问到了只有子类才有的属性。就像我们前面的代码中,
父类中的定义是:
public void publicPrintProperty(){
System.out.println("P....Parent public 方法");
System.out.println("P....p1 =" + p1);
System.out.println("P....p2 =" + p2);
}
子类中的定义是:
public void publicPrintProperty(){
System.out.println("C....Child public 方法");
System.out.println("C....c1 =" + c1);
System.out.println("C....c2 =" + c2);
}
其中,C2是只有子类才具有的属性,但是在父类构造器中却调用到了该方法。
也就是说,按照Java对象创建过程,当该方法被执行的时候C2还没有被初始化。
在这种情况下,Java会根据属性的类型不同,采用不同的缺省值进行处理。
这也就是为什么父类构造器执行的时候
C2=0
子类构造器执行的时候
C2=2000的原因。实际上,Java在处理创建子类对象的时候,在所有工作开始之前,先为继承层次中每个类的对象分配内存。然后在做其他工作。这样可以保证不管对象是否产生,起码属性已经先有了一个缺省值。本篇文章来源于 广州软件人才培训基地 转载请以链接形式注明出处 网址:http://www.toedu.org/Article/Java/Article_202.html
1. 静态的属性和静态的语句块都是在类加载的时候完成,非静态的东西是在创建对象的时候执行的.2. 单个类的初始化顺序如下:
静属->静块->非静属->非静块->构造函数.3. 有继承关系的类的初始化顺序如下:
父静属->父静块->子静属->子静块
->父非静属->父非静块->父构造->子非静属->子非静块->子构造.
关于只是调用了子类构造方法的声明,使用了SUPER,但没有执行子类构造的方法的方法体,有点难理解,但个个人都这样说,那我也只能这样理解了,如果有个人能给我讲讲内存的实时分配情况就好了。好了,结贴吧,看来应该也没什么人会进来踩的了。。