这个程序是如何执行的及原因
class StaticCode
{
int num=9;
StaticCode()
{
System.out.println("b");
}
static
{
System.out.println("a");
}
{
System.out.println("c"+this.num);
}
StaticCode(int x)
{
System.out.println("d");
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
public static void main(String[] args)
{
new StaticCode(4);
}
}

<div class="blockcode"><blockquote>class StaticCode {
        int num = 9;

        StaticCode() {//无参数构造函数
                System.out.println("b");
        }

        static {//静态语句块：static后跟上一个{},{}中的代码叫做静态语句块。
                System.out.println("a");//1. 当执行一个类时，首先执行静态语句块，所以首先此句语句。
        }
        {//动态语句块：运行类的构造函数时，首先运行的是动态语句块，然后再运行构造函数中的代码。动态语句块相当于把它里面的语句放在构造函数中的第一行位置。
                //无论你运行的是哪个构造函数，动态语句块都会先运行。
                System.out.println("c" + this.num);//2. 执行构造函数时，首先执行此句语句。
        }

        StaticCode(int x) {
                System.out.println("d");//3. 执行完动态语句后，执行此句语句。
        }

        public static void show() {//静态方法，只有调用其时才会执行其中的语句块，如：StaticCode.show()。
                System.out.println("show run");
        }
}
</blockquote></div><br />

这个程序是如何执行的及原因//分析如下： class StaticCode { int num=9; StaticCode() { System.out.println("b"); } static { System.out.println("a"); }//2.静态代码块，随着类的加载而执行 ，且执行一次，所以先输出a    { System.out.println("c"+this.num);//3.构造代码块，也优于对象执行，仅次于静态代码块，所以再次输出c9 } StaticCode(int x) { System.out.println("d");//4.执行这一句，输出d。程序执行完毕。 } public static void show() { System.out.println("show run"); } } class StaticCodeDemo { public static void main(String[] args) { new StaticCode(4);//1.加载类，并创建一个对象并传参数4 } }

首先你要了解类初始化的顺序，之后就可以理解你的程序了。
初始化顺序依次是（静态变量、静态初始化块）>（变量、初始化块）>构造器

详细资料请看http://www.cnblogs.com/jackyrong/archive/2008/08/12/1266161.html

• public class InitialOrderTest {
•   
•     // 静态变量
•     public static String staticField = "静态变量";
•     // 变量
•     public String field = "变量";
•   
•     // 静态初始化块
•     static {
•         System.out.println(staticField);   
•         System.out.println("静态初始化块");
•     }   
•     // 初始化块
•     {   
•         System.out.println(field);
•         System.out.println("初始化块");
•     }   
•     // 构造器
•     public InitialOrderTest() {
•         System.out.println("构造器");
•     }   
•     public static void main(String[] args) {
•         new InitialOrderTest();
•     }   
• }
  

运行以上代码，我们会得到如下的输出结果：

• 静态变量
• 静态初始化块
• 变量
• 初始化块
• 构造器
  

//-------------------------------------------所以你的程序运行顺序是1,2,3,4
class StaticCode
{
int num=9;//=========2  变量
StaticCode()
{
System.out.println("b");
}
static
{
System.out.println("a");//=====》1  静态初始化块
}
{
System.out.println("c"+this.num);//======》3  初始化块
}
StaticCode(int x)//=======》4  构造器
{
System.out.println("d");
}
public static void show()
{
System.out.println("show run");
}
}
class StaticCodeDemo
{
public static void main(String[] args)
{
new StaticCode(4);
}
}

该程序主要考察静态代码快、构造代码块以及构造函数的执行顺序。明白了他们之间的执行顺序，就不难理解改程序的执行顺序了。
静态代码块顺着类的加载而加载，类一加载它就执行，不管此时有没有创建对象；
构造代码块是给该类所有对象惊醒初始化，故只要有对象创立，构造代码块就执行；
构造函数是给该类的相对应对象进行初始化，即创建相对应的该类对象时，调用相对应的构造函数。

class StaticCode
{
        int num=9;
        StaticCode()
        {
                System.out.println("b");
        }
         static//2、静态代码块随着类的加载而加载，故加载类StaticCode后执行该静态代码块，打印a
         {
                System.out.println("a");
         }
         //3、接着执行构造代码块，打印c9
        {
                System.out.println("c"+this.num);
        }
         StaticCode(int x)//4、最后执行相对应的构造函数，打印d
        {
                 System.out.println("d");
        }
         public static void show()
        {
                System.out.println("show run");
         }
         }
class StaticCodeDemo
{
         public static void main(String[] args)
        {
                new StaticCode(4);//1、主函数执行该语句，加载类StaticCode
        }
}