1. class Father {
   
2.     static{
   
3.         System.out.println("Father static");
   
4.     }
   
5. 
   
6.     public Father(){
   
7.         System.out.println("Father create");
   
8.     }
   
9. }
   
10. class Child extends Father{
    
11.     static{
    
12.         System.out.println("Child static");
    
13.     }
    
14. 
    
15.     public Child(){
    
16.         System.out.println("Child create");
    
17.     }
    
18. }

复制代码

像这样的两个类，当调用Father f = new Child()；的时候是怎样的结果？主要想知道具体的执行顺序，这时候创建的Father实例f是否会运行Father的静态块呢

吕书凯 发表于 2012-9-20 22:35
如果创建父类引用并指向子类对象，则代码如下：
class Father
{

这个Father static的来源是Father f还是new Child()呢？

关于这个问题你可以百度下java中的static，如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象，所以先打印Father static和Child static，和Child类继承了Father类，所以在Child()构造方法前是先调用Father()构造方法，事实上所有我们写的类的构造方法中都要先写父类的构造方法即Object()构造方法。就是这样了

01.class Father {

02.    static{                                                     //这是一个静态代码块，它的作用是给类初始化的，随着类的加载而加载。
                                                                       //意思是Father类在的时候，它就存在，也就是对象还没建立，它就存在了
03.        System.out.println("Father static");    // 所以它会优先执行。

04.             }

05.

06.    public Father(){                                     //这个是构造方法。调用它的时候，才执行。不调用就不执行。
                                                                      //如果子类对象建立的时候，就后调用到此构造方法，
07.        System.out.println("Father create"); //所以子类对象建立的时，这里会执行打印

08.    }

09.}

10.class Child extends Father{                         //这是子继承父，先要到执行到父类，再执行子类。

11.    static{                                                       //Child类的静态代码块，给Child类初始化，随Child类加载而加载。

12.        System.out.println("Child static");

13.    }

14.

15.    public Child(){                                          //这是构造方法，调用时才执行，不调用就不执行。
                                                                        //建立Child类的对象时，则调用该方法。
16.        System.out.println("Child create");     

17.    }

public static void main(String[] agurs)
    {
            Father f = new Child();
    }

//结果是：Father static
                 Child static
                 Father create
                 Child create

我同意一楼的看法，我的理解我一楼的理解一样，但是static 语句和static代码块一般很少使用，因为它的生命周期最长。
如果创建父类引用并指向子类对象，则代码如下：
class Father
{
    static
    {
        System.out.println("Father static");
    }

    public Father(){
        System.out.println("Father create");
    }
}
class Child extends Father
{
    static
    {
        System.out.println("Child static");
    }

    public Child()
    {
        System.out.println("Child create");
    }
    public static void main(String[] agurs)
    {
            Father f = new Child();
    }
}
代码运行结果如下：

Father static
Child static
Father create
Child create
从结果来看，由于静态代码块随着类的加载而最先加载，所以创建父类引用指向子类对象时
首先运行父类静态代码块并打印，然后是子类静态代码块运行。
之后就是构造方法的加载，首先加载父类的构造方法并打印结果
最后执行子类的构造方法。
总之：静态代码块在类加载时就加载，优先于构造方法，并且优先加载父类的静态代码块和父类的构造方法