class Test {
        
        public static void main(String[] args) {
                new B();               
        }        
}

class A {
        static {
                System.out.println("A");        
        }
        {
                System.out.println("B");
        }
        A() {        
                this(123);
                System.out.println("C");
        }        
        A(int i) {
                System.out.println("D");
        }
}
class B extends A {
        static {
                System.out.println("E");
        }
        {
                System.out.println("F");
        }
        B() {
                this(123);
                System.out.println("G");
        }
        B(int i) {
                System.out.println("H");
        }
}


请问结果是什么，执行顺序是怎么样的

静态代码块随着类的加载而加载
构造代码块对象一建立就运行，且先于构造函数运行。
class Test
{
      
public static void main(String[] args)
                {
                new B();               
        }      
}

class A
{
           /*
           1，加载A类的静态代码块，输出A
           */
        static
                {
                System.out.println("A");      
        }
                /*
           3，加载A类的构造代码块，输出B
           */
        {
                System.out.println("B");
        }
                /*
           4，加载A类的构造函数，
           */
        A()
                {      
                this(123);//调用本类中的A(int i) {}构造函数，输出D
                System.out.println("C");//接着输出C
        }
               
        A(int i)
                {
                System.out.println("D");
        }
}
class B extends A
        {
                /*
           2，加载B类的静态代码块，输出E
           */

        static
                {
                System.out.println("E");
        }
                /*
           5，加载B类的构造代码块，输出F
           */
        {
                System.out.println("F");
        }
                /*
           6，加载B类的构造函数
           */
        B()
                {
                this(123);//调用本类的 B(int i) {}构造函数，输出H
                System.out.println("G");//输出G
        }
        B(int i)
                {
                System.out.println("H");
        }
}
结果为
A
E
B
D
C
F
H
G

结果是AEBDCFHG  分析如下：
虚拟机从main入口执行，执行到这句的时候，就创建对象 ，会加载Ｂ.class文件，
由于Ｂ类 继承了Ａ类，所以会先加载父类的A.class文件，静态代码块是随着类的加载就在内存中存在了，所以先输出Ａ
接着加载子类的B.class文件，就执行了Ｂ类中的静态代码块输出E，Ｂ类的静态走完后，Ｂ类要初始化，要先走父类的初始化，
所以先执行构造代码块输出B,接着，父类的无参构造函数用this调用了本类的有参构造函数，传入了123,有参构造函数就执行了，输出了D。
有参构造函数初始化完后，无参构造函数接着执行下一句输出C,到这里后，父类A就全部初始化完毕。
接着初始化子类B,B类先执行构造代码块输出F，接着，子类也有一个无参构造函数和有参构造函数的重载形式，执行无参构造函数时，里面用this调用了本类的
有参构造函数，所以要先到有参构造函数里进行初始化输出H，有参构造函数初始化完毕，无参构造函数接着执行，输出G，到这里就全部执行完了。
所以结果是AEBDCFHG
class Test {
        
        public static void main(String[] args) {
                new B();
        }        
}

class A {
        static {
                System.out.println("A");//第一步：先加载父类的A.class进内存，静态代码块随着类加载就存在了，所以输出A        
        }
        {
                System.out.println("B");//第三步：父类优先初始化，构造代码块先执行，输出B
        }
        A() {        
                this(123);
                System.out.println("C");//第五步：有参函数初始化完后，接着执行下一句输出C
        }        
        A(int i) {
                System.out.println("D");//第四步：这个跟无参构造函数是重载的，无参构造函数用this调用了此构造函数，输出D
        }
}
class B extends A {
        static {
                System.out.println("E");//第二步：接着加载子类B.class进内存，静态代码块执行输出E
        }
        {
                System.out.println("F");//第六步：父类全部初始化完毕，执行子类的构造代码块输出F
        }
        B() {
                this(123);
                System.out.println("G");////第八步：有参构造函数初始化完毕，无参构造函数接着执行，输出G，到这里就全部执行完了。
        }
        B(int i) {
                System.out.println("H");//第七步：无参构造函数用this传值调用了有参构造函数，有参构造函数就先初始化执行后输出H
        }
}

//A E B D C F H G  没什么  注意的地方是静态的特性，//A B D C E F H G这是我认为的结果，呵呵  猜错了，由于静态先加载，所以E排在B前面，失误失误··

static 方法在构造方法前， B 覆盖了A 的static 方法，所以应该是

E
H
G


没有编译，不知对不对