先声明，老鸟赶紧飘过~~
在论坛上搜索了一下静态代码块，发现很多人在帮别人解答的时候也给出了错误的答案。
一些知识不太扎实的人（我今天之前也是理解错误），认为静态代码块是随着类的加载而加载。
这是错误的。请看下面的测试程序

1. /*
   
2. 需求：测试构造代码块、静态构造代码块的执行顺序。
   
3. */
   
4. 
   
5. class StaticCode1
   
6. {
   
7.         static
   
8.         {
   
9.                 System.out.println("StaticCode1——————静态代码块");
   
10.         }
    
11.         {
    
12.                 System.out.println("StaticCode1————————代码块");
    
13.         }
    
14. }
    
15. 
    
16. class StaticCode
    
17. {
    
18.         static
    
19.         {
    
20.                 System.out.println("StaticCode静态代码块——————");
    
21.         }
    
22.         {
    
23.                 System.out.println("StaticCode代码块————————");
    
24.         }
    
25. }
    
26. 
    
27. class StaticCodeDemo
    
28. {
    
29.         static
    
30.         {
    
31.                 System.out.println("StaticCodeDemo静态代码块1");
    
32.         }
    
33.         {
    
34.                 System.out.println("StaticCodeDemo代码块");
    
35.         }
    
36.         public static void main(String[] args)
    
37.         {
    
38.                 //连续创建两个StaticCode类的对象，静态代码块之执行一次，非静态代码块执行两次
    
39.                 new StaticCode();
    
40.                 new StaticCode();
    
41. 
    
42.                 //同一个类中有多个静态代码块，按由上到下顺序执行
    
43.                 new StaticCodeDemo();
    
44. 
    
45.                 //StaticCode1类已经加载，但是代码块却没有运行；
    
46.                 StaticCode1 code1=null;
    
47.                 StaticCode1 code12;
    
48. 
    
49.                 System.out.println("over");
    
50.         }
    
51.         static
    
52.         {
    
53.                 System.out.println("StaticCodeDemo静态代码块2");
    
54.         }
    
55. }

复制代码

运行的结果为（有图有真相）

游客，如果您要查看本帖隐藏内容请回复

上面的测试代码也说明了程序的运行是：先创建main函数所在类的对象然后才找到main函数执行。

嗯 解释的很好 顶一个

你好,分享下
            static{
                  静态代码块中的执行语句
            }
        特点：随着类的加载而执行，只执行一次并优先于主函数。 用于给类进行初始化。
Persong   p  = new  Person("XX",XX);
这句话执行了：
   <1> 因为new用到了Person.class，所以会先找到Persong.class文件并加载到内存中
   <2> 执行该类中的static代码块，如果有的话，给Person.class类进行初始化
   <3> 在堆内存中开辟空间，分配内存地址
   <4> 在堆内存中建立对象特有属性，并进行默认初始化
   <5> 对属性进行初始化
   <6> 对对象进行构造代码块初始化
   <7> 对对象进行对应的构造函数初始化
   <8> 将内存地址赋给栈内存中的p变量
这就是一个很好的实现过程,画图会清晰的看到每一步.....

来看看是怎么回事。

smile_joe 发表于 2013-4-19 22:56
你好,分享下
            static{
                  静态代码块中的执行语句

你说的这些步骤都正确，但是好像没有证明你说的
随着类的加载而执行
没有代码，没有运行结果图，你这样的说法很空洞

隐藏的是什么好东东啊

正是我问的问题，讲的很透彻，{:soso_e152:}

/*

需求：测试构造代码块、静态构造代码块的执行顺序。

*/

class StaticCode1

{

        static

        {

                System.out.println("StaticCode1——————静态代码块");
        }

        {

                System.out.println("StaticCode1————————代码块");
        }

}

class StaticCode

{

        static

        {

                System.out.println("StaticCode静态代码块——————");
        }

        {

                System.out.println("StaticCode代码块————————");
        }

}

class StaticCodeDemo

{

        static

        {

                System.out.println("StaticCodeDemo静态代码块1");
        }

        {

                System.out.println("StaticCodeDemo代码块");
        }

        public static void main(String[] args)
        {

                //连续创建两个StaticCode类的对象，静态代码块之执行一次，非静态代码块执行两次

                new StaticCode();

                new StaticCode();

                //同一个类中有多个静态代码块，按由上到下顺序执行

                new StaticCodeDemo();

                //StaticCode1类已经加载，但是代码块却没有运行；

                StaticCode1 code1=null;

                StaticCode1 code12;

                System.out.println("over");
        }

        static

        {

                System.out.println("StaticCodeDemo静态代码块2");
        }

}

我帮你分析一下：在主函数执行前要先加载主函数所在的类，在主函数所在类加载的同时，该类的
的静态代码块就会从上往下执行一次，输出的是System.out.println("StaticCodeDemo静态代码块1");
和System.out.println("StaticCodeDemo静态代码块2"); 在执行主函数的时候，因为 new StaticCode();
有两次，所以会先输出System.out.println("StaticCode静态代码块——————");一 次（在同一个函数中
多次建立同一个对象，该对象的静态代码块只执行一次），输出System.out.println("StaticCode代码块————————");
两次，执行到new StaticCodeDemo();时，本类对象的静态代码已经执行过一次这里不会再执行，而执行的是构造
代码块，输出的是System.out.println("StaticCodeDemo代码块");执行到StaticCode1 code1=null;和StaticCode1 code12;时
因为没有建立对象，所以没有任何输出，最后执行System.out.println("over"); 所以你看到的结果就是
StaticCodeDemo静态代码块1
StaticCodeDemo静态代码块2
StaticCode静态代码块——————
StaticCode代码块————————
StaticCode代码块————————
StaticCodeDemo代码块
over

我来凑个热闹，从未隐藏的代码来看，个人觉得不能说明你所说明的问题。
//StaticCode1类已经加载，但是代码块却没有运行；
                StaticCode1 code1=null;
                StaticCode1 code12;
这里没有创建任何对象，从设计的合理性来猜测，StaticCode1 code1=null;
                和StaticCode1 code12，既然没有创建对象，就没有必要加载类。
除非有其它的证据说明，这里类已经被加载。
    以上只是合理性猜测，如果你有更好的证据。

补充下：   你只要把第四十三行注释掉，看看运行结果。就发现，这个结论是错误的：先创建main函数所在类的对象然后才找到main函数执行。
好了，先说明，我不是要故意来找茬哈，只是对这些特别的地方特别感兴趣，想弄清楚究竟。

看看！学习！！

静态代码块不是在类加载时被调用的，而是第一个实例对象被创建时才执行的。

我的理解---
创建实例对象，要加载类！应该是先加载类，同时静态代码块被调用；

1. class StaticCode{
   
2.          static
   
3.      {
   
4.              System.out.println("StaticCode静态代码块——————");
   
5.      }
   
6.      {
   
7.              System.out.println("StaticCode代码块————————");
   
8.      }
   
9. }
   
10. 
    
11. class StaticCode1 extends StaticCode
    
12. {
    
13.         static
    
14.         {
    
15.                 System.out.println("StaticCode1——————静态代码块");
    
16.         }
    
17.         {
    
18.                 System.out.println("StaticCode1——————代码块");
    
19.         }
    
20. }
    
21. 
    
22. public class Test {
    
23.         public static void main(String[] args){
    
24.                 StaticCode1 code1 = new StaticCode1();//创建StaticCode1的实例，但会加载器父类
    
25.                 System.out.println("over");
    
26.         }
    
27. }

复制代码

结论：静态代码块是随着类的加载而加载

我只是想看隐藏文件来自: Android客户端

黑马伍哲沂 发表于 2013-4-20 11:42
补充下：   你只要把第四十三行注释掉，看看运行结果。就发现，这个结论是错误的：先创建main函数所在类的 ...

很高兴你提出不同的见解:handshake
张孝祥老师是从字节码上解析的，建议你看一下张老师的基础加强1

黑马伍哲沂 发表于 2013-4-20 11:42
补充下：   你只要把第四十三行注释掉，看看运行结果。就发现，这个结论是错误的：先创建main函数所在类的 ...

很高兴你提出不同的观点，对不起，因为我没有提前说明，我的意思：先创建main函数所在类的对象然后才找到main函数执行  我是说隐式创建（这点我忘了提前说明了）
43行的代码 我只是想证明一个类中有多个静态代码块时是按由上到下执行的  不是为了证明你说的这一点的。

你可以用代码从字节码上分析一下。建议你回看一下张老师的基础加强1。

黑马伍哲沂 发表于 2013-4-20 11:42
补充下：   你只要把第四十三行注释掉，看看运行结果。就发现，这个结论是错误的：先创建main函数所在类的 ...

很高兴你提出不同的观点，对不起，因为我没有提前说明，我的意思：先创建main函数所在类的对象然后才找到main函数执行  我是说隐式创建（这点我忘了提前说明了）
43行的代码 我只是想证明一个类中有多个静态代码块时是按由上到下执行的  不是为了证明你说的这一点的。

你可以用代码从字节码上分析一下。建议你回看一下张老师的基础加强1。

丘凤光 发表于 2013-4-21 13:19
很高兴你提出不同的观点，对不起，因为我没有提前说明，我的意思：先创建main函数所在类的对象然后才找到 ...

嗯  我会看的。  还没看到张老师的加强部分。
但这里还是有个问题，从程序运行的结果来看，如果把43行注释掉，虽然主函数中静态代码块会被执行。、
但我发现构造代码块却没有执行。  只有43行没被注释才会执行。
如果这个疑问能从张老师的视频里得到解答，就不用回复我了。也许我看到那里才能理解。

看看隐藏的再来 讨论。

黑马伍哲沂 发表于 2013-4-21 14:10
嗯  我会看的。  还没看到张老师的加强部分。
但这里还是有个问题，从程序运行的结果来看，如果把43行注 ...

嗯，你这个问题我没考虑到。要是这样的话，这和张老师的就矛盾了……
看来得请教真正的大神了。

楼主的代码中，46,47行并没有加载类