新手问：java代码运行逻辑问题？

Question

下面这段代码，说明java程序的执行逻辑？import java.io.*;
　　class SuperClass{
　　　　int x;
　　　　SuperClass( ) {
　　　　　x=3;
　　　　　System.out.println("in SuperClass : x=" +x);
　　　　}
　　　　　void doSomething( ) {
　　　　　System.out.println("in SuperClass.doSomething()");
　　　　}
　　}
　　class SubClass extends SuperClass {
　　　　int x;
　　　　SubClass( ) {
　　　　　super( ); 　　　//调用父类的构造方法
　　　　　x=5;　　　　　　//super( ) 要放在方法中的第一句
　　　　　System.out.println("in SubClass :x="+x);
　　　　}
　　　　　void doSomething( ) {
　　　　　super.doSomething( ); //调用父类的方法
　　　　　System.out.println("in SubClass.doSomething()");
　　　　　System.out.println("super.x="+super.x+" sub.x="+x);
　　　　}
　　}
　　public class Inheritance {
　　　　　public static void main(String args[]) {
　　　　　SubClass subC=new SubClass();
　　　　　subC.doSomething();
　　　　}
　　}
在dos中，输入java Inheritance,java程序开始执行的思路是不是这样：首先，SubClass subC=new SubClass();执行subclass中的所有语句，在执行中遇到superclass,会把superclass中的代码执行一遍：最后程序应该在屏幕上输出输出8次请高手讲解？

Answer 1

class A0 {
    A0() {
        System.out.println("父类的构造函数被调用（初始化父类）");
    }
}class A1 extends A0 {
    static final int b = print1();
    static {
        System.out.println("静态块被执行");
    }
    int a = print();
    {
        System.out.println("非静态块被执行");
    }    A1() {
        System.out.println("A1 的构造函数被调用");
    }    private int print() {
        System.out.println("A1中非静态变量被初始化");
        return 1;
    }    final static int print1() {
        System.out.println("A1中静态变量被初始化");
        return 1;
    }
}class A2 extends A1 {
    A2() {
        System.out.println("A2构造函数被调用");
    }
}public class DeriveDemo {
    public static void main(String[] args) {
        System.out.println("这是A1类的初始化顺序");
        A1 a = new A1();
        System.out.println("\n这是A2类的初始化顺序");
        A2 a1 = new A2();
        System.out.println("\n这是A2类的初始化顺序（注意静态变量）");
        A2 a2 = new A2();
        System.out.println("");
        System.out.println("我们还注意到静态变量被A2全盘继承下来了");
    }
}运行结果为
这是A1类的初始化顺序
A1中静态变量被初始化
静态块被执行
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用这是A2类的初始化顺序
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用
A2构造函数被调用这是A2类的初始化顺序（注意静态变量）
父类的构造函数被调用（初始化父类）
A1中非静态变量被初始化
非静态块被执行
A1 的构造函数被调用
A2构造函数被调用我们还注意到静态变量被A2全盘继承下来了

Answer 2

类的初始化顺序:第一次执行main()方法,初始化子类对象时--子类的静态变量--子类的静态代码块--父类的静态变量--父类的静态代码块--父类的非静态变量--父类的非静态代码块--父类的构造方法--子类的非静态变量--子类的非静态代码块--子类的构造方法.
第二次执行时--父类的非静态变量--父类的非静态代码块--父类的构造方法--子类的非静态变量--子类的非静态代码块--子类的构造方法.
(类里面的static修饰的代码块只加载一次).

Answer 3

上面说的比较详细 补充下 象{
        System.out.println("非静态块被执行");
    }
他只在第一次初始化对象时 运行一次 以后就不运行了，他是相对于对象的 和STATIC相对于类是一样的

Answer 4

C:\test>java Inheritance
in SuperClass : x=3
in SubClass :x=5
in SuperClass.doSomething()
in SubClass.doSomething()
super.x=3 sub.x=5

Answer 5

3楼的别误人好不好 是从根父类的静态域开始的 不是从子类静态域开始
楼主给你发个初始化顺序的代码class Meal{
{
System.out.println("Meal");
}
static{
System.out.println("Meal.static");
}
Meal(){
System.out.println("Meal()");
}
}
class Bread{
{
System.out.println("Bread");
}
static{
System.out.println("Bread.static");
}
Bread(){
System.out.println("Bread()");
}
}
class Cheese{
{
System.out.println("Cheese");
}
static{
System.out.println("Cheese.static");
}
Cheese(){
System.out.println("Cheese()");
}
}
class Lettuce{
{
System.out.println("Lettuce");
}
static{
System.out.println("Lettuce.static");
}
Lettuce(){
System.out.println("Lettuce()");
}
}
class Lunch extends Meal{
{
System.out.println("Lunch");
}
static{
System.out.println("Lunch.static");
}
Lunch(){
System.out.println("Lunch()");
}
}
class PortableLunch extends Lunch{
{
System.out.println("PortableLunch");
}
static{
System.out.println("PortableLunch.static");
}
PortableLunch(){
System.out.println("PortableLunch()");
}
}
public class Sandwich extends PortableLunch{
private Bread b = new Bread();
private Cheese c = new Cheese();
private Lettuce l = new Lettuce();
static{
System.out.println("Sandwich.static");
}
{
System.out.println("Sandwich");
}
public Sandwich(){
System.out.println("Sandwich()");
}
public static void main(String[] args){
new Sandwich();
}
}输出结果为
Meal.static
Lunch.static
PortableLunch.static
Sandwich.static
Meal
Meal()
Lunch
Lunch()
PortableLunch
PortableLunch()
Bread.static
Bread
Bread()
Cheese.static
Cheese
Cheese()
Lettuce.static
Lettuce
Lettuce()
Sandwich
Sandwich()