黑马程序员技术交流社区

标题: 关于静态初始化块，，，怎么看晕了。谁能解释一下 [打印本页]
作者: zgjswp    时间: 2015-3-9 22:57
标题: 关于静态初始化块，，，怎么看晕了。谁能解释一下
  1. class Root {
  2.     static {
  3.         System.out.println("Root的静态初始化块");
  4.     }
  5.     {
  6.         System.out.println("Root的普通初始化块");
  7.     }

  9.     public Root() {
  10.         System.out.println("Root的无参数的构造器");
  11.     }
  12. }

  14. class Mid extends Root {
  15.     static {
  16.         System.out.println("Mid的静态初始化块");
  17.     }
  18.     {
  19.         System.out.println("Mid的普通初始化块");
  20.     }

  22.     public Mid() {
  23.         System.out.println("Mid的无参数的构造器");
  24.     }

  26.     public Mid(String msg) {
  27.         this();
  28.         System.out.println("Mid的带参数构造器，其参数值：" + msg);
  29.     }
  30. }

  32. class Leaf extends Mid {
  33.     static {
  34.         System.out.println("Leaf的静态初始化块");
  35.     }
  36.     {
  37.         System.out.println("Leaf的普通初始化块");
  38.     }

  40.     public Leaf() {
  41.         super("测试语句");
  42.         System.out.println("执行Leaf的构造器");
  43.     }
  44. }

  46. public class Test {
  47.     public static void main(String[] args) {
  48.         new Leaf();
  49.         new Leaf();
  50.     }
  51. }<p></p>
复制代码
结果是：
Root的静态初始化块
Mid的静态初始化块
Leaf的静态初始化块
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：测试语句
Leaf的普通初始化块
执行Leaf的构造器
Root的普通初始化块
Root的无参数的构造器
Mid的普通初始化块
Mid的无参数的构造器
Mid的带参数构造器，其参数值：测试语句
Leaf的普通初始化块
执行Leaf的构造器
作者: 空洞的望着窗外    时间: 2015-3-9 23:02
静态代码块优先加载~~~
作者: zgjswp    时间: 2015-3-9 23:17
空洞的望着窗外 发表于 2015-3-9 23:02
静态代码块优先加载~~~

为啥普通初始化块也在构造函数前运行
作者: 执念    时间: 2015-3-9 23:19
有那么复杂吗
作者: 1021361407    时间: 2015-3-10 19:25
类一加载静态代码块就出来了，只执行一次，然后每new一个对象代码块运行，然后是构造函数
作者: pop1234o    时间: 2015-3-10 20:38
静态语句快在类加载的时候就加载进来，只有一次，普通语句快和 构造方法是new对象的时候才有
作者: lwj123    时间: 2015-3-10 22:52
我也是有点晕晕的
作者: ㏒假™面具    时间: 2015-3-10 23:08
静态代码块随着类的加载而加载，所以不管是父类的或是子类的静态代码块都会先运行
作者: android-liu    时间: 2015-3-10 23:22
我先给你分析一下我写的程序，然后再看你的。你可能就会明白了
  1. public class Day08_1{
复制代码
最后的执行顺序是这样的* 代码块的执行顺序
* 1.Day08_1的静态代码块执行了
2.main函数执行了
3.Student的静态代码块执行了
4.构造代码块执行了
5.构造函数执行了
6.构造代码块执行了
分析：当JVM要想执行一个程序时，1.首先要找main方法，于是Day_8类就加载到了内存，静态代码块是一个类加载到内存时执行的，也就是类初始化的。所以1.Day08_1的静态代码块执行了第一个执行；2.接着main方法执行,于是2.main函数执行了执行了;3.接着new Student（）时，Student类加载到了内存，所以3.Student的静态代码块执行了（并且只执行一次）；4，接着new Sutdent()时，｛｝括起来的是对象初始化代码块，里面都是所有对象共有的内容，先于构造函数执行，所以构造代码块执行了，（并且每次调构造函数都会执行）；5.构造函数执行了；6.构造代码块执行了


作者: zgjswp    时间: 2015-3-11 00:09
android-liu 发表于 2015-3-10 23:22
我先给你分析一下我写的程序，然后再看你的。你可能就会明白了最后的执行顺序是这样的* 代码块的执行顺序[/ ...

首先谢谢你的解答，好像代码不全吧，只看到了第一行。。。
作者: android-liu    时间: 2015-3-11 13:36
  1. package com.xiangying;

  3. public class Day08_1 {

  5.         /**
  6.          * 代码块的执行顺序
  7.          *  1.Day08_1的静态代码块执行了
  8.                 2.main函数执行了
  9.                 3.Student的静态代码块执行了
  10.                 4.构造代码块执行了
  11.                 5.构造函数执行了
  12.                 6.构造代码块执行了
  13.          */
  14.        
  15.         public static void main(String[] args) {
  16.                 System.out.println("main函数执行了");
  17.                 Student s=new Student();
  18.                 Student s1=new Student();

  20.         }
  21. static {
  22.                
  23.                 System.out.println("Day08_1的静态代码块执行了");
  24.         }

  26. }
  27. class Student{
  28.         {
  29.                 System.out.println("构造代码块执行了");
  30.                
  31.         }
  32.         static{
  33.                 System.out.println("Student的静态代码块执行了");
  34.         }

  36.         public Student(){
  37.                 System.out.println("构造函数执行了");
  38.         }
  39.        
  40.        
  41.        
  42. }
复制代码




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