黑马程序员技术交流社区

标题: 静态代码块,构造代码块,构造函数,局部代码块 [打印本页]

作者: 明月几时有    时间: 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. }  

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


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


作者: 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. }

  17. public class Test
  18. {
  19.         static
  20.         {
  21.                 System.out.println("主方法所在类中的静态代码块");
  22.         }
  23.         public static void main(String[] args)
  24.         {
  25.                 new Person();
  26.                 new Person();
  27.                 new Person();
  28.                 Person.show();
  29.         }
  30. }
复制代码

作者: 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