java类中包含静态成员、方法时的打印顺序

class Base{
    static{
         System.out.println("{父类加载}");
         }
     static int a=getValue("静态：获取父类a值");
     Base(){
          System.out.println("调用父类无参构造函数，现打印父类a赋值结果："+a);
          a++;
          printA();
      }
     {
          System.out.println("{父类实例初始代码块}");    
      }
     Base(String s){
          System.out.println("父类带参构造函数"+s);    
      }
     void printA(){
         System.out.println("父类赋值结果a="+a);
     }
     static int getValue(String s){
          System.out.println("静态：父类原始a="+a);
          System.out.println(s);
          return ++a;
      }
 }
public class Child extends Base{
    static{
         System.out.println("{子类加载}");    
     }
     static Child child=new Child();
     static int a=getValue("静态：获取子类a值");
     
    Child(){
         System.out.println("调用子类无参构造函数，现打印子类a赋值结果:"+a);
         a++;
         printA();
     }
    {
          System.out.println("{子类实例初始代码块}");    
      }
     Child(String s){
          System.out.println("子类带参构造函数"+s);    
      }
    void printA(){
         System.out.println("子类赋值结果a="+a);
     }
    static int getValue(String s){
         System.out.println("静态：子类原始a="+a);
         System.out.println(s);
         return ++a;
     }
    public static void main(String[] args){
         //new Child("实例化子类");
         new Child();
     }
 }

打印结果如下：

---------------------------------------------------------

{父类加载}
静态：父类原始a=0
静态：获取父类a值
{子类加载}
{父类实例初始代码块}
调用父类无参构造函数，现打印父类a赋值结果：1
子类赋值结果a=0
{子类实例初始代码块}
调用子类无参构造函数，现打印子类a赋值结果:0
子类赋值结果a=1
静态：子类原始a=1
静态：获取子类a值
{父类实例初始代码块}
调用父类无参构造函数，现打印父类a赋值结果：2
子类赋值结果a=2
{子类实例初始代码块}
调用子类无参构造函数，现打印子类a赋值结果:2
子类赋值结果a=3

-------------------------------------------------------------------

 

例子中有如下几处刻意设计的难点：

1.父子类都有同名变量a，考察静态变量在继承中的表现；

2.静态成员child在初始化时即被实例化，先于静态变量a的赋值，考察a的赋值顺序；

3.静态代码块和实例代码块的区别；

4.printA()是实例方法，考察当实例化子类时，在父类构造方法中调用实例方法是否有多态；

 

分析：

1.继承顺序：当实例化子类时，会先加载父类，并给父类的静态变量分配空间和自动初始化，其值和实例变量初始化值相同，初始化时可以调用静态方法；然后才加载子类，并给子类的静态变量分配空间，此时如果静态的类成员需要实例化，则调用子类构造方法。而进入子类构造方法时，最先调用super()，所以进入父类无参构造方法，此时调用的实例方法一定是子类重写的方法，因为堆中只有子类的实例方法。

 

2.初始化顺序：当静态的类成员和静态的基本变量同时初始化时，其先后顺序取决于语句顺序。

 

3.实例代码块仅当构造方法中调用super()之后才被调用，每次实例化都会被调用一次；而静态代码块则只在类被第一次加载时调用，且只运行一次。

 

4.静态变量：静态变量属于类，存在于代码区，内存中只有1份，为所有实例共享，任何实例对其修改都会影响到它的值。

 

5.语句顺序：

static Child child=new Child();

static int a=getValue("静态：获取子类a值");

注意这里的顺序导致了子类加载之后立即在堆中实例化了一个child对象，而在代码区中并未执行到静态变量a的声明，即：

static int a=getValue("静态：获取子类a值");

故先后出现父子类构造函数的打印语句，然后才是"静态：获取子类a值"。