class Test
{
        static int num = 4;
        {
                        num+=3;
        }
        Test()
        {               
        }static
        {       
        }

       
}
new Test();
请问我在歘创建对象的时候程序执行的步骤？

class Test
{
        static int num = 4;
        {       //创建对象后才能加载，这里属于第三个加载
          num+=3;
          System.out.println(num);
        }
        Test(){   //类的构造函数，第二个加载
                System.out.println("a");
        }
        static {            //静态函数，第一个加载
                System.out.println("b");
        }
        public static void main(String[] args){
                new Test();
        }       
}
运行后的结果为 b 7  a   可以看到程序执行顺序

运科兄弟大义！讲解的这么详细，我插不上话了！{:soso_e179:}

这是静态代码块部分的内容！在第6天的第6节有讲解！

执行顺序是 静态块->构造块->构造方法 记住此顺序
class Test
{
        static int num = 4;
        {//此为构造块，第二个被加载
                        num+=3;
        }
        Test()
        {                //此为构造方法，最后被加载
        }static
        {        //此为静态块，最先被加载
        }

        
}
new Test();

1. 经过多次修订，网上你能找到的此类问题的最全面解答的就在本帖了，因为笔者花费了大量的时间去总结这个问题，大概一天半吧，可能是技术有限啊，不过写出来的绝对是精华！换个地方你可能找不到比这个更完整的回答！因为笔者还有同学们已经找过了！当然说的是在之前的时间中！

复制代码

// 注意看，这里仅仅是一个普遍情况，特殊情况下面有总结：在下面的A ，B两种情况的总结非常的重要，一定要好好的看看！
public classExten

    {

       static int num = 4;                    // 静态变量第二个

           {

              num += 3;

              System.out.println("b");

           }

           int a = 5;{                             // 成员变量第三个

              System.out.println("c");

           }

        Exten()

           {                                         // 类的构造函数，第四个加载

              System.out.println("d");

           }

       static

           {                                        // 静态块，第一个加载

              System.out.println("a");

           }

       static void run()                     // 静态方法，调用的时候才加载

           {

              System.out.println("e");

           }

       public static void main(String[] args)

           {

              new Exten();                    // new对象是检测执行的最好方法

           }

总结：
1、静态代码块（只加载一次） 2、构造方法（创建一个实例就加载一次）3、静态方法需要调用才会执行，所以最后结果没有e

扩展：
      这里我们继续思考：静态变量，静态块交换顺序，或者多个静态变量共存，多个静态块共存，结果就会变化，为什么呢，是不是顺序变化了呢。
        其实不是的，是我们对"概念"的理解有偏差！请看大补充！

大补充：   

A、类的初始化顺序如下：

->1、为静态属性分配内存并赋值（后面大括号语句不执行，这里是初始化，只是添加变量和值）或者  执行静态代码块（立刻执行大括号里面的语句）

          为什么这样说呢，因为谁在前先加载谁，包括静态属性之间，和静态块之间的顺序，
          但是注意，虽然顺序都可以当第一，但是静态块、静态属性执行的东西完全不一样，怎么不一样，已经写上去了自己看
      （笔者注：这个问题，在花了很多时间的推敲后，最终有了答案，前后花了不少的时间去运行代码，修改各种情况，也有同学参与了进来，所以大家对我们付出的努力应该尊重啊）
->2、为非静态属性分配内存并赋值

->3、构造方法（实际上这个先于非静态属性调用到，只是构造方法里面的语句暂停执行，等到非静态属性加载完才执行）

->4、执行非静态代码块 或 静态方法（都是调用了才加载）。

B、类的代码(大括号内的语句)执行顺序：   当你创建了对象的时候才会用到各个属性和变量对不对，这里就是这个顺序

->1、执行静态代码块（大括号包含的语句立刻执行，绝对是第一位的执行，没有能和它平级的）

->2、静态属性 （第二位执行）

->3、为非静态属性分配内存并赋值（大括号内语句第三位执行）

->4、构造函数

->执行非静态代码块 或 静态方法（都是调用了才加载）。

  
这样的话是不是非常的清晰呢了！终于在笔者的努力中，在一些同学不断响应的思考中，这个问题最终解决！
本帖精心总结，希望能给大家带来一些帮助和思考！

    }

王运科 发表于 2012-4-24 12:24
class Test
{
        static int num = 4;

二楼写的有错误，第二个加载的是i静态变量，详情看楼下总结

1. class Test
   
2. {
   
3.         static int num = 4; //2、加载静态成员变量
   
4.         
   
5.                 //4、加载构造代码块
   
6.                 {
   
7.              num+=3;
   
8.         }
   
9. 
   
10.         Test()//5、加载构造方法
    
11.         {        
    
12.         }
    
13. 
    
14.                 static //3、加载静态代码块
    
15.         {        
    
16.         }
    
17. 
    
18.         
    
19. }
    
20. new Test();//1、由于用到了new，所以先将Test.class加载内存
    
21. 
    
22. /*
    
23. 总结：
    
24.         类初始化顺序：静态变量、静态初始化块-->变量、构造代码块-->构造方法
    
25. 
    
26.         静态变量、静态初始化块之间
    
27.         变量、构造代码块之间                        取决它们在类中出现的先后顺序
    
28. */

复制代码

黄或俊 发表于 2012-4-24 13:16

表示同意！