Java的class编译和运行循环，先有鸡还是先有蛋！

如果有两个方法，互相调用，那么何时了呢？

这个问题早在1、2年前就发现过了，可以用  来解决，但是这种先有鸡还是先有蛋的问题还是又碰见了~

 

/**
 * 下面有问题吗？请仔细看看
 * 如果告诉你是考试类的加载机制的，你能看出问题来吗？
 * 看不出来就看看答案吧~
 */
public class SimpleTest {

    public void f(){
        B b = new B();
    }
   
    public static void main(String[] args) {
        SimpleTest obj = new SimpleTest();
        obj.f();
    }
}
class A{
    static{
        System.out.println("class A loaded!");
    }
    public A(){
        System.out.println("A init!");
    }
    B b = null;
}
class B{
    static{
        System.out.println("class B loaded!");
    }
    public B(){
        System.out.println("B init!");
    }
    A a = null;
}
/*
 * 答案是：没有问题。
 * 运行输出是：
class B loaded!
B init!
 * class A并没有被加载，虽然类B中看见了A，但是类A并没有被用到，既没有用到new
 * 也没有碰到使用类A的静态成员，因此类A没有被加载！
 */

 

/**
 * 再往下看吧~
 * 看不出来就看看答案吧~
 */
public class SimpleTest {

    public void f(){
        B b = new B();
    }
   
    public static void main(String[] args) {
        SimpleTest obj = new SimpleTest();
        obj.f();
    }
}
class A{
    static{
        System.out.println("class A loaded!");
    }
    public A(){
        System.out.println("A init!");
    }
    B b = null;
}
class B extends A {
    static{
        System.out.println("class B loaded!");
    }
    public B(){
        System.out.println("B init!");
    }
    A a = null;
}

/*
 * 答案是：没有问题。
 * 运行输出是：
class A loaded!
class B loaded!
A init!
B init!
 * new B时，先加载父类static成员，之后加载子类static成员，
 * 接着父类A的实例成员b初始化null（此时因为只是看到了B并没有用，因此不加载类B）
 * 最后初始化B
 */

 

/** 继续吧~ */

class A{
    static{
        System.out.println("class A loaded!");
    }
    public A(){
        System.out.println("A init!");
    }
    B b = new B() ;
}
class B extends A {
    static{
        System.out.println("class B loaded!");
    }
    public B(){
        System.out.println("B init!");
    }
    A a = null;
}
/*
 * 答案是：有问题！！
 * 运行输出是：
class A loaded!
class B loaded!
Exception in thread "main" java.lang.StackOverflowError
    at com.june.study.class_compile_resircle.A.<init>(SimpleTest.java:53)
    ...
 * new B时，先加载父类static成员，之后加载子类static成员，
 * 接着父类A的实例成员b初始化new B()（此时因为不只是看到了B还要用，因此必须加载类B）
 * 但是加载类B的前提是类A的成员b必须正确初始化后才行，这就导致了不停的循环：有B需先有A，有A需先有B
 * ，最后java的stack检测到运行期异常了！这里编译确实没有问题的！！
 */

 

这是运行期异常，但编译期没有异常哦！！

 

再看看这个吧~

package study_sun.reflect.Reflection;

public class A {
    B b = null;
    public void link(B b){
        this.b = b;
        b.link(this);
    }
}

package study_sun.reflect.Reflection;

public class B {
    A a = null;
    public void link(A a){
        this.a = a;
        a.link(this);
    }
   
    public static void main(String[] args){
        A a = new A();
        B b = new B();
        a.link(b);
    }
}
/* 结果：Exception in thread "main" java.lang.StackOverflowError */

 

如果换成这样呢！

class A {
    B b = null;
    public void link(B b){
        this.b = b;
//        b.link(this);
        if(Reflection.getCallerClass(2) != B.class)b.link(this);
    }
}
class B {
    A a = null;
    public void link(A a){
        this.a = a;
        //a.link(this);
        if(Reflection.getCallerClass(2) != A.class) a.link(this);
    }
}

// okay~