JVM理论：（三/7）关于类变量、成员变量、局部变量的案例总结

//案例1 —— 针对初始化的时机
public class StaticTest {  
    public static int k = 0;  
    public static StaticTest t1 = new StaticTest("t1");  
    public static StaticTest t2 = new StaticTest("t2");  
    public static int i = print("i");  
    public static int n = 99;  
    public int j = print("j");        
    {  
        print("构造块");  
    }    
    static{  
        print("静态块");  
    }  
    public StaticTest(String str) {  
        System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);  
        ++n;  
        ++i;  
    }        
    public static int print(String str) {  
        System.out.println((++k) + ":" + str + " i=" + i + " n=" + n);  
        ++i;  
        return ++n;  
    }     
    public static void main(String[] args) {  
        StaticTest t = new StaticTest("init");  
    }  
}

输出结果：
//要执行main方法前，会先初始化main方法所在的类StaticTest，对于Java来说，一旦开始初始化静态部分，无论是否完成，后续都不会再重新触发静态初始化流程了，类的静态初始化只会进行一次。下面一条一条对输出结果进行分析。

1:j i=0 n=0　　　　　
2:构造块 i=1 n=1
3:t1 i=2 n=2
//前3句一起分析，要执行main方法前，会先初始化main方法所在的类StaticTest，按顺序从上到下开始初始化静态变量，但是当执行到 public static StaticTest t1 = new StaticTest("t1"); 时发现需要先创建一个对象，
//这里虽然StaticTest类的初始化还未完成，但也不会再重新触发一次，不会再次初始化静态变量，所以直接开始初始化成员变量，直接执行 public int j = print("j"); ，所以第一句打印的是与 j 相关的，继续初始化对象，
//接着执行构造块和构造方法。值得注意的是，这时StaticTest类的静态变量i,n都还没执行到赋值语句，所以这时都还是系统的零值，为0。

4:j i=3 n=3
5:构造块 i=4 n=4
6:t2 i=5 n=5
//4-6句与第一部分类似，创建另一个对象t2，这时也还没有执行到静态变量i,n的赋值语句。

7:i i=6 n=6
//开始执行静态变量i的赋值语句 public static int i = print("i"); ，会把n的值7返回给i，值得注意的是这里给i赋值后，前面不管i的值是什么都会变成新值。

8:静态块 i=7 n=99
//public static int n = 99; ，不管n之前的值为多少，这里初始化后的n为99，此时已经完成对类StaticTest静态变量的初始化，这句话是执行静态代码块时打印的。

9:j i=8 n=100
10:构造块 i=9 n=101
11:init i=10 n=102
//以上已经完成在执行main前对main方法所在类StaticTest的静态初始化，此时开始执行main方法里的语句StaticTest t = new StaticTest("init");，同样以成员变量，构造块，构造函数的顺序执行。

//案例2 —— 针对构造方法的选择
public class SonClass extends ParentClass{
  ParentClass parentClass;
  public SonClass(){
    System.out.println("1");
  }
  public SonClass(String name){
    System.out.println("2");
    this.name = name;
    parentClass = new ParentClass("FEI");
  }
  public static void main(String[] args) {
    System.out.println("------ main start ------ ");
    new SonClass("fei");
    System.out.println("------ main end ------ ");
  }
}
 
public class ParentClass{
  String name ;
  public ParentClass(){
    System.out.println("3");
  }
  public ParentClass(String name){
    System.out.println("4");
    this.name = name ;
  }
}

//如果子类没有显示地调用父类构造函数，不管子类是否存在带参数的构造方法都默认调用父类无参的构造函数，若父类没有无参的构造方法则编译出错。
输出结果：
------ main start ------ 
3        //调用子类构造方法SonClass(String name)前先调父类的构造，且没有显示调用父类构造方法，所以调的是ParentClass()
2        //继续执行子类构造方法SonClass(String name)
4        //执行到parentClass = new ParentClass("FEI");，会调用父类中带参的构造方法ParentClass(String name)
------ main end ------ 

public class TestClass {
   private static void testMethod(){
        System.out.println("testMethod");
   }
   public static void main(String[] args) {
        ((TestClass)null).testMethod();
   }
}

输出结果：    
testMethod

//1)此处是类对方法的调用，不是对象对方法的调用。
//2)null可以被强制类型转换成任意类型（不是任意类型对象），于是可以通过它来执行静态方法。
//3)若将testMethod()方法前的static去掉，变成实例方法，必须依赖对象被创建后才能使用，会报空指针异常 。