下面是代码摘字《Thinking In Java》，如果我没看过这本书，我也不懂。

问题：1、你在不用工具运行下面的代码，你可以推测结果么？请如实回答。
      2、 用工具运行得出结果，能根据结果解说缘由吗？

这是一个问题，也是一个调查，请如实回答，请勿搜索百度，那不是你我需要的答案。
只有清晰的知道自己的短处，才能补短，才知道自己应该着力的地方。[code=java]package day10.one;

class Bowl {
        Bowl(int marker) {
                System.out.println("Bowl(" + marker + ")");
        }

        void f(int marker) {
                System.out.println("f(" + marker + ")");
        }
}

class Table {
        static Bowl b1 = new Bowl(1);

        Table() {
                System.out.println("Table()");
                b2.f(1);
        }

        void f2(int marker) {
                System.out.println("f2(" + marker + ")");
        }

        static Bowl b2 = new Bowl(2);
}

class Cupboard {
        Bowl b3 = new Bowl(3);
        static Bowl b4 = new Bowl(4);

        Cupboard() {
                System.out.println("Cupboard()");
                b4.f(2);
        }

        void f3(int marker) {
                System.out.println("f3(" + marker + ")");
        }

        static Bowl b5 = new Bowl(5);
}

public class StaticInitialization {
        public static void main(String[] args) {
                System.out.println("Creating new Cupboard() in main");
                new Cupboard();
                System.out.println("Creating new Cupboard() in main");
                new Cupboard();
                t2.f2(1);
                t3.f3(1);
        }

        static Table t2 = new Table();
        static Cupboard t3 = new Cupboard();
}[/code]

* 关于执行顺序，说明以下几点：
* 1.static字段是基于类的，非static字段是基于对象的。
* 2.调用一个类的static方法。首先，如果该类的static字段未初始化，则初始化，否则忽略；其次，再调用该static方法。
* 3.创建一个类的对象。首先，如果该类有static字段且没有初始化，则初始化，否则初始化该类的非static字段；其次，再调用该类相应的构造方法。

Bowl1
Bowl2
Table()
f1
Bowl4
Bowl5
Cupboard()
f2
Creating new Cupboard in main
Cupboard()
f2
Creating new Cupboard in main
Cupboard()
f2
f21
f31
和答案有点差距，
我推断错误的原因是：知道加载类时，加载静态成员，而忽视了在加载静态类时，在类里有引用其他对象会先把其他对象调用运行，在运行自己的构造方法，

Bowl(1)
Bowl(2)
Table()
f(1)
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)
Creating new Cupboard() in main
Bowl(4)
Bowl(5)
Bowl(3)
Cupboard()
f(2)
f2(1)
f3(1)
我的答案也不对,以前看过这方面的知识点,但又忘了被静态修饰时只在类被加裁时执行一次，只后不会再被执行。
如果在能混合进重载和继承就更为经典了.我就借这个发个构造函数重载的,大家也分析下:
class Cake{
   Cake(){System.out.println("Cake()");}
}

class Meal {
  Meal() { System.out.println("Meal()"); }
}

class Bread {
  Bread() { System.out.println("Bread()"); }
}

class Cheese {
  Cheese() { System.out.println("Cheese()"); }
}

class Lettuce {
  Lettuce() { System.out.println("Lettuce()"); }
}

class Lunch extends Meal {
  Lunch() { System.out.println("Lunch()"); }
}

class PortableLunch extends Lunch {
  private Cake a=new Cake();
  PortableLunch() { System.out.println("PortableLunch()");}
}

public class OverLoadTest extends PortableLunch
{
  private Bread b = new Bread();
  private Cheese c = new Cheese();
  private Lettuce l = new Lettuce();
  
  public OverLoadTest() {
    System.out.println("Sandwich()");
  }
  
  public static void main(String[] args)  {
    new OverLoadTest();
  }
}

史晓霞 发表于 2011-11-12 09:28
Bowl1
Bowl2
Table()

有个小混淆：这里没有静态类，你想说的应该是调用类的静态方法，会初始化类的静态字段（如果没有初始化）。关于静态类，只要访问其成员，就要初始化（如果没有初始化）。