public abstract class ActionFactory
{
    static ActionFactory defaultActionFactory;
    static ActionFactory actionFactoryImplementation;

    static   //我指的是这段static代码
    {
        // Create default implementation
        try
        {
            String className = Configuration.getString("webwork.action.factory");
            try
            {
                defaultActionFactory = (ActionFactory)Thread.currentThread().getContextClassLoader().loadClass(className).newInstance();
            }
            catch (Exception e)
            {
                LogFactory.getLog(ActionFactory.class).error("Could not instantiate action factory:" + e);
                defaultActionFactory = new DefaultActionFactory();
            }
        }
        catch (IllegalArgumentException ex)
        {
            LogFactory.getLog(ActionFactory.class).error("Could not instantiate configuration:" + ex);
            defaultActionFactory = new DefaultActionFactory();
        }
    }

    /**
     * Returns the matching action found as the result of traversing the action factory delegation chain.
     * @param aName name of action to return
     * @return action located through the factory delegation chain
     */
    public static Action getAction(String aName) throws Exception
    {
        return getActionFactory().getActionImpl(aName);
    }

    /**
     * Returns the action factory implementation or the default action factory if not available.
     * @return action factory implementation
     */
    public static ActionFactory getActionFactory()
    {
        return actionFactoryImplementation == null ? defaultActionFactory : actionFactoryImplementation;
    }

    /** Set the action factory implementation. Can only be called once. */
    public static void setActionFactory(ActionFactory aFactory) throws IllegalStateException
    {
        //      new Throwable().printStackTrace();
        if (actionFactoryImplementation != null)
            throw new IllegalStateException("May only set action factory implementation once");
        actionFactoryImplementation = aFactory;
    }

    /**
     * Returns the action object for the specified action or a matching action on the action factory delegation chain.
     * @param aName name of action to check for a match
     */
    public abstract Action getActionImpl(String aName) throws Exception;
}

scottding wrote:
当这个类加载的时候就开始了，注意，这个时候还没有构造，是在构造之前。

mitnickcbc wrote:
在你第一次使用这个类的static元素或第一次构造对象时，
先调用static代码。
按我的理解就是作任何有关这个类的事时都先调用static代码。

yadan wrote:
这段static代码只运行一次，就是最先用这个类时执行。对吗？
是不是第一次用到这个类时执行之后，再有子类实例化时就不会再执行这段代码了？

ｈｏｈｏ，发现他头像下面多了一行字哦，Ｊｕｔｅ　Ｕｓｅｒ，还有一个金杯哦。羡慕中~~~~~~~~~~~~~~

snowbug wrote:
The order of the class initialization:
1. static variables and static blocks, based on the order they appear in the class (this only happens at the first time the class is accessed)
2. the non-static variables
3. constructor

The above steps (1 through 3) are repeated top-down in the class inheritance tree. For example, if class A is the sub-class of B and B is the sub-class of the root class Object, then the following initialization will occur when you call A a = new A();:
i) do step 1 through 3 for the root class Object
ii) do step 1 through 3 for class B
iii) do step 1 through 3 for class A

snowbug wrote:
The order of the class initialization:
1. static variables and static blocks, based on the order they appear in the class (this only happens at the first time the class is accessed)
2. the non-static variables
3. constructor

The above steps (1 through 3) are repeated top-down in the class inheritance tree. For example, if class A is the sub-class of B and B is the sub-class of the root class Object, then the following initialization will occur when you call A a = new A();:
i) do step 1 through 3 for the root class Object
ii) do step 1 through 3 for class B
iii) do step 1 through 3 for class A

In StaticB static block - 1 - run only once 
sb=static variable sb
In StaticA static block - 2 - run only once
sa=static variable sa
In StaticB constructor - 3
In StaticA constructor - 4
In StaticB constructor - 3
In StaticA constructor - 4

package statictest;

public class StaticA extends StaticB
{
  public String nsa = "non-static variable nsa";
  static public String sa = "static variable sa";

  static
  {
    System.out.println("In StaticA static block - 2 - run only once");
    System.out.println("sa=" + sa);
  }

  public StaticA()
  {
    super();
    System.out.println("In StaticA constructor - 4");
  }
}

package statictest;

public class StaticB
{
  public String nsb = "non-static variable nsb";
  static public String sb = "static variable sb";

  static
  {
    System.out.println("In StaticB static block - 1 - run only once ");
    System.out.println("sb=" +  sb);
  }

  public StaticB()
  {
    super();
    System.out.println("In StaticB constructor - 3");
  }
}

package statictest;

public class StaticTest
{
  public static void main(String[] args)
    {
    StaticA sa = new StaticA();
    StaticA sa1 = new StaticA();
  }
}

Breeze wrote:
这个说法应该是错误的。
具体应该是这样的：
1、root->B->A,执行step 1.
2、root执行step 2,step3
3、B执行step 2,step 3
4、A执行step 2,step 3.