黑马程序员技术交流社区

标题: 静态代码块，构造代码块，构造函数，局部代码块 [打印本页]
作者: 明月几时有    时间: 2013-11-4 22:12
标题: 静态代码块，构造代码块，构造函数，局部代码块
本帖最后由 明月几时有 于 2013-11-6 10:59 编辑

一下子学了这几个代码块，简直快晕了，执行的先后顺序让我很头疼，下面列举这段代码，希望大神能利用这段代码帮我理清这些代码块的执行顺序是怎样的，以及各自的特点和区别。闲言少叙，上代码。
  1. class StaticCode  
  2. {        
  3.         {
  4.                 System.out.println("F");
  5.         }         
  6.            static   
  7.     {  
  8.         System.out.println("A");  
  9.     }  
  10.     public void show()  
  11.     {  
  12.         System.out.println("B");  
  13.     }  
  14. }  
  15. class StaticCodeDemo  
  16. {  
  17.     static   
  18.     {  
  19.             System.out.println("C");  
  20.     }  
  21.     public static void main(String[] args)  
  22.     {  
  23.         new StaticCode().show();  
  24.                         {
  25.                         System.out.println("D")
  26.                         }
  27.     }  
  28.         static  
  29.     {  
  30.         System.out.println("E");  
  31.     }  
  32. }  
复制代码
作者: 咸鱼要吃猫    时间: 2013-11-4 23:11
  1. class StaticCode  
  2. {        
  3.         {
  4.                 System.out.println("F");
  5.         }         
  6.            static   
  7.     {  
  8.         System.out.println("A");  
  9.     }  
  10.     public void show()  
  11.     {  
  12.         System.out.println("B");  
  13.     }  
  14. }  

  16. /*
  17. 从程序入口开始按顺序读下去。
  18. 首先找到主函数main（），发现主函数所在class StaticCodeDemo{}中存在静态代码块static{}。
  19. 所以按照顺序---啪啪---第一个输出的就是"C"。紧接着第二个输出就是主函数main（）下面的"E"。
  20. 然后开始继续读主函数main（），发现调用了StaticCode()中的show（）。
  21. 跳转到class StaticCode{}。
  22. 发现class StaticCode{}中也存在静态代码块static{}，按照顺序第三个输出"A"。
  23. 又发现class StaticCode{}中也存在构造代码块，所以第四个接着输出"F"。
  24. 然后开始调用show（），第五个就输出了"B".
  25. 最后返回主函数输出"D"。
  26. */
  27. class StaticCodeDemo  
  28. {  
  29.     static   
  30.     {  
  31.             System.out.println("C");  
  32.     }  


  35.     public static void main(String[] args)  
  36.     {           
  37.         new StaticCode().show();
  38.                         {
  39.                         System.out.println("D");
  40.                         }
  41.     }  
  42.         static  
  43.     {  
  44.         System.out.println("E");  
  45.     }  
  46. }  
复制代码
构造代码块：在对象一建立就运行的，优先构造函数。
构造代码块是给所有对象统一初始化。
构造函数是给对应对象初始化。
静态代码块：在类加载时，就自动执行，优先于主函数，只执行一次

作者: mayor125    时间: 2013-11-4 23:21
Java中有4中代码块，普通代码块、构造代码块、静态代码块和同步代码块。你这个例子中出现了前面3种代码块。
1、普通代码块：在语句或者方法中使用的代码块。
2、构造代码块：在类中使用的代码块。
3、静态代码块：用static修饰符修饰的代码块。

总结：
1、静态代码块优先于主方法执行，且只执行一次。
2、构造代码块优先于普通代码块先执行，且随着对象的建立可以不断的重复执行。

下面贴一个例子：
  1. class Person
  2. {
  3.         {
  4.                 System.out.println("1、构造代码块");
  5.         }
  6.         static
  7.         {
  8.                 System.out.println("3、静态代码块");
  9.         }
  10.         public static void show()
  11.         {
  12.                 {
  13.                         System.out.println("2、普通代码块");
  14.                 }
  15.         }
  16. }

  18. public class Test
  19. {
  20.         static
  21.         {
  22.                 System.out.println("主方法所在类中的静态代码块");
  23.         }
  24.         public static void main(String[] args)
  25.         {
  26.                 new Person();
  27.                 new Person();
  28.                 new Person();
  29.                 Person.show();
  30.         }
  31. }
复制代码
作者: ixiangfeng    时间: 2013-11-4 23:21
对象初始化过程：
1.在栈内建立变量
2.类加载进内存
3.执行静态代码块
4.在堆内存中开辟空间，分配内存地址
5.在堆内存中建立对象的特有属性，并进行默认初始化
6.对属性进行显示初始化
7.对对象进行构造代码块初始化
8.对对象进行对应的构造函数初始化
9.将内存地址赋给栈内存中的变量

作者: 剑魂    时间: 2013-11-4 23:24
首先main函数所在类中的静态代码块先执行CE，然后执行main函数，main函数中new用到了StaticCode类，然后执行StaticCode中的静态代码块A，对对象进行初始化时，执行构造代码块初始化F,然后调用Show()B,最后主函数，输出D
作者: 冯国强    时间: 2013-11-5 02:17
class StaticCode
{
                                //4
    {
       System.out.println("F");
    }
    static                     //3
   {
      System.out.println("A");
   }
   public void show()
  {
     System.out.println("B");
  }
}
class StaticCodeDemo
{
  static                    //1
  {
      System.out.println("C");
  }
  public static void main(String[] args)
{
      new StaticCode().show();//5
     {
          System.out.println("D")
     }
}
  static                 //2
{
          System.out.println("E");
}
}
上述涉及到了静态，构造函数，局部代码块的执行顺序；由于程序首先执行的是主线程，因为静态代码块是随着类的加载而加载，优先于对象存在并优先于主函数执行。所以先执行类StaticCodeDemo中的静态代码块，然后执行StaticCode类中的静态代码块。再执行 { System.out.println("F"); }构造代码块，因为构造代码块是对象一建立，就执行并优先于构造函数。最后执行匿名函数。
所以结果是CEAFBD
作者: 黄炳期    时间: 2013-11-5 08:38
认真整理答案吧，同时感谢各位解答！
帖子已分类，若仍有疑惑，可重新发问
作者: 明月几时有    时间: 2013-11-5 19:04
谢谢各位耐心细致的回答，我明白了



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2