黑马程序员技术交流社区

标题: 静态代码块问题 [打印本页]

作者: xiaobo 时间: 2014-1-27 10:41
标题: 静态代码块问题
格式：
static
{
静态代码块中的执行语句。
}

特点：随着类的加载而执行，只执行一次,并优先于主函数。
用于给类进行初始化的。
下面代码的执行顺序为什么是b c a c9 d？

class StaticCode
{
int num = 9;
StaticCode()
{
System.out.println("b");
}
static
{
System.out.println("a");
}
{
System.out.println("c"+this.num);
}
StaticCode(int x)
{
System.out.println("d");
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
static
{
System.out.println("b");
}
public static void main(String[] args)
{
new StaticCode(4);
}
static
{
System.out.println("c");
}
}

复制代码

作者: 唐志海 时间: 2014-1-27 11:35
StaticCodeDemo类一加载就执行该类中的静态代码块，所以先输出了b、c再看主函数，new StaticCode(4);就把staticCode类加载进内存，所以就执行该类的静态代码块，所以就输出了a，接着执行代码块的东西，代码块是给所有对象初始化的，所以优先于构造函数执行，所以就输出了c跟9，最后执行构造函数，给该对象进行初始化，输出了d。。依此输出的顺序是b c a c9 d

作者: 周昭民 时间: 2014-1-27 11:53
当加载StaticCodeDemo类时，两个静态代码块优先于mian方法，会先被执行，输出b和c，然后再进入mian创建匿名对象。而在对象被加载时，也是优先执行静态代码块，输出a。然后构造代码被执行，输出c9，最后构造方法，输出d，完成对象的初始化。执行结果是b c a c9 d

可以看一下我写的代码

/*
1、静态代码块优先于mian方法执行
2、静态代码块优先于构造代码块执行
3、构造代码块优先于构造方法执行
静态代码块>构造代码块>构造方法
输出结果为：d b a c
*/
package com.staticdemo;
public class StaticCodeDemo2
{
static {
System.out.println("d"); //第一
}
public static void main(String args[]){
StaticDemo d1=new StaticDemo();
}
}
class StaticDemo
{
{
System.out.println("a"); //第三
}
static{
System.out.println("b"); //第二
}
StaticDemo(){
System.out.println("c"); //第四
}
}

复制代码

作者: zhangchao 时间: 2014-1-27 13:19
虽然执行结果相同，但顺序不对，我认为执行顺序为：静态代码块>构造方法>构造代码块，可以通过子父类继承来验证
如有不当，请指正
/*
1、静态代码块优先于mian方法执行
2、静态代码块优先于构造代码块执行
3、构造代码块优先于构造方法执行

静态代码块>构造代码块>构造方法
输出结果为：d b a c
*/

package com.staticdemo;

      public class StaticCodeDemo2
      {
            static {
                     System.out.println("d");             //第一
            }
            public static void main(String args[]){
                     StaticDemo d1=new StaticDemo();
            }
      }

      class StaticDemo
      {
            {
                     System.out.println("a");             //第三
            }

            static{
                     System.out.println("b");             //第二

            }

            StaticDemo(){
                     //这里有隐式调用，你可以自己写个子类继承就知道了
                     //super();
                     //成员属性显式初始化
                     //构造代码块
                     //下面才是构造方法中的代码
                     System.out.println("c");             //第四
            }
      }

作者: 周昭民 时间: 2014-1-28 12:22
  StaticDemo(){
                     //这里有隐式调用，你可以自己写个子类继承就知道了
                     //super();
                     //成员属性显式初始化
                     //构造代码块
                     //下面才是构造方法中的代码
                     System.out.println("c");             //第四
            }
先不写子类继承，现在此处的super()就是在调用Object类对象了，我明白你的意思
但我觉得在静态代码块完成初始化之后，要是同时存在构造代码块和构造方法，就肯定会预先加载构造代码块的
而构造方法则是在构造代码块初始化之后加载。
当加载构造方法时，分两步走，1、先初始化父类构造方法 2、再初始化本类构造方法
因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。
而super()，那个隐式调用就是在此处进行的吧。（此处只有继承Object，没有继承其他类）
之后才初始化本类构造方法

作者: 周昭民 时间: 2014-1-28 12:23

zhangchao 发表于 2014-1-27 13:19
虽然执行结果相同，但顺序不对，我认为执行顺序为：静态代码块>构造方法>构造代码块，可以通过子父类继承来 ...

  StaticDemo(){
                     //这里有隐式调用，你可以自己写个子类继承就知道了
                     //super();
                     //成员属性显式初始化
                     //构造代码块
                     //下面才是构造方法中的代码
                     System.out.println("c");             //第四
            }
先不写子类继承，现在此处的super()就是在调用Object类对象了，我明白你的意思
但我觉得在静态代码块完成初始化之后，要是同时存在构造代码块和构造方法，就肯定会预先加载构造代码块的
而构造方法则是在构造代码块初始化之后加载。
当加载构造方法时，分两步走，1、先初始化父类构造方法 2、再初始化本类构造方法
因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，要先看父类是如何对自己的内容进行初始化的。
而super()，那个隐式调用就是在此处进行的吧。（此处只有继承Object，没有继承其他类）
之后才初始化本类构造方法
这是我对此处的理解，请指教

作者: zhangchao 时间: 2014-1-28 13:06

周昭民发表于 2014-1-28 12:23
StaticDemo(){
//这里有隐式调用，你可以自己写个子类继承就知道了
...

为什么说让你写个继承打印你就明白呢？因为Object类你没法打印log信息，如果能打印的话，你就明白了，之前我也是和你理解的顺序是一样的，看了毕老师的代码示例，实际打印后发现确实不是你说的顺序。我自己验证用的代码:
class ObjectInstanceDemo {
public static void main(String[] args) {
new Son();
}
}

class Parent
{
Parent() {
System.out.println("Parent constructor run...");
show();
}
void show() {
System.out.println("Parent show run...");
}
}
class Son extends Parent
{
int num = 9;
{
System.out.println("constructor code run..." + num);
}
Son(){
//super();
//变量显式初始化
//构造代码块
System.out.println("son constructor run..." + num);
}
void show(){
System.out.println("son show run..." + num);
}
}

输出结果：
//如果不不是先执行构造方法，super()从哪执行？
Parent constructor run...

son show run...0
constructor code run...9
son constructor run...9

请指教。

作者: 周昭民 时间: 2014-1-28 14:18

zhangchao 发表于 2014-1-28 13:06
为什么说让你写个继承打印你就明白呢？因为Object类你没法打印log信息，如果能打印的话，你就明白了，之 ...

厉害！感谢大神的指导，确实执行结果是这样，我也觉得好惊讶，颠覆了我对加载过程的理解。可是什么log信息，能够解释一下吗，或者说，你是在哪看的毕老师的代码例子，求分享一下，谢谢

作者: zhangchao 时间: 2014-1-28 22:13

周昭民发表于 2014-1-28 14:18
厉害！感谢大神的指导，确实执行结果是这样，我也觉得好惊讶，颠覆了我对加载过程的理解。可是什么log信 ...

大神不敢当，初学而已，我是在毕老师的java35天的视频里看到的，在传智播客的官网上有下载链接

作者: 周昭民 时间: 2014-1-29 12:01

zhangchao 发表于 2014-1-28 22:13
大神不敢当，初学而已，我是在毕老师的java35天的视频里看到的，在传智播客的官网上有下载链接 ...

恩，好，谢谢分享，以后有问题再请教你

作者: GISQZC 时间: 2014-2-8 09:32
好好学习毕老师的视频！

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2