现在的位置: 首页 > 综合 > 正文

java中的代码块理解和初始化（alibaba引发的学习） java中的代码块理解Java初始化

2017年11月02日 ⁄ 综合 ⁄ 共 6185字 ⁄ 字号 小 中 大 ⁄ 评论关闭

java中的代码块理解

2010-03-09 10:44 448人阅读 评论(2) 收藏 举报
javaclassstring

代码块：就是用{}括起来到部分。根据应用的不同分为4类:普通代码块、构造块、静态代码块、同步代码块。

1.普通代码块：定义在方法中的代码块。

如：

[java] view
plaincopy

  1. public class Ex22 {     
  2.     
  3.     public static void main(String[] args){     
  4. //      普通代码块     
  5.         {     
  6.             int i = 3;     
  7.             System.out.println("局部变量为 " + i);     
  8.         }     
  9.         int i = 5;     
  10.         System.out.println("相对上面的  i 来说是全局的变量 " + i);     
  11.              
  12.     }     
  13.     
  14.          
  15. }     
  16. //局部变量为 3     
  17. //相对上面的  i 来说是全局的变量 5   

2.构造块：直接在类中编写的代码块。

[java] view
plaincopy

  1. class Demo5{     
  2.     {     
  3.         System.out.println("构造块");     
  4.     }     
  5.     public Demo5(){     
  6.         System.out.println("构造方法");     
  7.     }     
  8.     {     
  9.         System.out.println("构造方法后的构造块");     
  10.     }     
  11. }     
  12. public class Ex22 {     
  13.     
  14.     public static void main(String[] args){     
  15.         new Demo5();     
  16.         new Demo5();     
  17.          
  18.     }     
  19.     
  20.          
  21. }     
  22. //构造块     
  23. //构造方法后的构造块     
  24. //构造方法     
  25. //构造块     
  26. //构造方法后的构造块     
  27. //构造方法    

对象被实例化一次构造块就执行一次；

构造块优先执行比构造方法.

3.静态代码块:static 关键字声明的代码块.

[java] view
plaincopy

  1. class Demo5{     
  2.     {     
  3.         System.out.println("1构造块");     
  4.     }     
  5.     public Demo5(){     
  6.         System.out.println("2构造方法");     
  7.     }     
  8.     {     
  9.         System.out.println("3构造方法后的构造块");     
  10.     }     
  11.     static {     
  12.         System.out.println("4静态代码块");     
  13.     }     
  14.              
  15. }     
  16. public class Ex22 {     
  17.     static {     
  18.         System.out.println("在主方法类中定义的代码块");     
  19.     }     
  20.          
  21.     public static void main(String[] args){     
  22.         new Demo5();     
  23.         new Demo5();     
  24.          
  25.     }     
  26.     
  27.          
  28. }     
  29. //在主方法类中定义的代码块     
  30. //4静态代码块     
  31. //1构造块     
  32. //3构造方法后的构造块     
  33. //2构造方法     
  34. //1构造块     
  35. //3构造方法后的构造块     
  36. //2构造方法   
  37.   
  38. 本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/njiang/archive/2009/10/27/4735707.aspx  

主方法静态代码块优先于主方法，

在普通类中静态块优先于构造块，

在普通类中构造块优先于构造方法，

静态块只实例化一次。

Java初始化顺序
1
 无继承情况下的Java初始化顺序：

class Sample
{
      Sample(String s)
      {
            System.out.println(s);
      }
      Sample()
      {
            System.out.println("Sample默认构造函数被调用");
      }
}
class Test{
      static Sample sam=new Sample("静态成员sam初始化");
      Sample sam1=new Sample("sam1成员初始化");
      static{
            System.out.println("static块执行");
            if(sam==null)System.out.println("sam
is null");
            sam=new Sample("静态块内初始化sam成员变量");
            }
      Test()
      {
            System.out.println("Test默认构造函数被调用");
      }

}
 public static void 
main(String  str[])
{

     Test a=new Test();

 }
输出结果为：
静态成员sam初始化
    -----静态成员初始化
static块执行
         -----静态块被执行
静态块内初始化sam成员变量 ----静态块执行
sam1成员初始化
     -----普通成员初始化
Test默认构造函数被调用
 -----构造函数执行


由此可以得出结论：
a 静态成员变量首先初始化（注意，Static可以看做一个静态成员，其执行顺序和其在类中申明的顺序有关）
b 普通成员初始化
c 执行构造函数。

对于静态成员（static块可以看成普通的一个静态成员，其并不一定在类初始化时首先执行）和普通成员，其初始化顺序只与其在类定义中的顺序有关，和其他因素无关。
例如下面的例子：


class Test{
      static{
            System.out.println("static
块 1  执行");
            }
      static Sample staticSam1=new Sample("静态成员staticSam1初始化");
      Sample sam1=new Sample("sam1成员初始化");
      static Sample staticSam2=new Sample("静态成员staticSam2初始化");
      static{
            System.out.println("static
块 2  执行");
            }
      Test()
      {
            System.out.println("Test默认构造函数被调用");
      }
      Sample sam2=new Sample("sam2成员初始化");

}


则结果为：
static
块 1  执行
静态成员staticSam1初始化
静态成员staticSam2初始化
static
块 2  执行 
  
                   --------静态成员
sam1成员初始化
sam2成员初始化
  
                   --------普通成员
Test默认构造函数被调用
  
                   --------构造函数


2 Java继承情况下的初始化顺序：

class Test{
      static{
            System.out.println("父类static
块 1  执行");
            }
      static Sample staticSam1=new Sample("父类
静态成员staticSam1初始化");
      Sample sam1=new Sample("父类
sam1成员初始化");
      static Sample staticSam2=new Sample("父类
静态成员staticSam2初始化");
      static{
            System.out.println("父类
static 块 2  执行");
            }
      Test()
      {
            System.out.println("父类
Test默认构造函数被调用");
      }
      Sample sam2=new Sample("父类
sam2成员初始化");

}

class TestSub extends Test
{
      static Sample staticSamSub=new Sample("子类
静态成员staticSamSub初始化");
      TestSub()
      {
            System.out.println("子类
TestSub 默认构造函数被调用");
      }
      Sample sam1=new Sample("子类
sam1成员初始化");
      static Sample staticSamSub1=new Sample("子类
静态成员staticSamSub1初始化");
      
      static{System.out.println("子类
static 块  执行");}
      Sample sam2=new Sample("子类
sam2成员初始化");
}

执行结果：
父类
static 块 1  执行
父类
静态成员staticSam1初始化
父类
静态成员staticSam2初始化
父类
static 块 2  执行
  
                     --------父类静态成员初始化
子类
静态成员staticSamSub初始化
子类
静态成员staticSamSub1初始化
子类
static 块  执行
  
                     -------子类静态成员初始化
父类
sam1成员初始化
父类
sam2成员初始化
父类
Test默认构造函数被调用       
  
                     -------父类普通成员初始化和构造函数执行
子类
sam1成员初始化
子类
sam2成员初始化
子类
TestSub 默认构造函数被调用
  
                     -------父类普通成员初始化和构造函数执行


由此得出Java初始化顺序结论：
1 继承体系的所有静态成员初始化（先父类，后子类）
2 父类初始化完成（普通成员的初始化-->构造函数的调用）
3 子类初始化（普通成员-->构造函数）


Java初始化顺序如图：
分类: Java&JVM
 

Java初始化

2013-09-23 08:21 23人阅读 评论(1) 收藏 举报
[java] view
plaincopy

  1. package dian;  
  2.   
  3. public class Test {  
  4.       
  5.     public static int k=0;  
  6.     public static Test t1=new Test("t1");  
  7.     public static Test t2=new Test("t2");  
  8.     public static int i=print("i");  
  9.     public static int n=99;  
  10.       
  11.     public int j=print("j");  
  12.     {  
  13.         print("构造块");  
  14.     }  
  15.     static{  
  16.         print("静态块");  
  17.     }  
  18.       
  19.     public Test(String s){  
  20.         System.out.println((++k)+":"+s+" i="+i+" n="+n);  
  21.         ++i;++n;  
  22.     }  
  23.     public static int print(String s){  
  24.         System.out.println((++k)+":"+s+" i="+i+" n="+n);  
  25.         ++n;  
  26.         return ++i;  
  27.     }  
  28.     /* 
  29.      * 类加载之后,按从上到下执行被static修饰的语句, 
  30.      * 如果有语句new了自身的对象,将从上到下执行构造代码块, 
  31.      * 构造器,创建完对象后,接着执行下面的static语句 
  32.      * */  
  33.     public static void main(String[] args){  
  34.         System.out.println("----main start-------");  
  35.         Test t=new Test("init");  
  36.         System.out.println("------main end-------");  
  37.     }  
  38. }     

1. 类记载之后，先从上到下执行static修饰的语句

2.如果static语句中new了自身的对象，将按照如下顺序执行：

(a) 初始化成员变量，没有设置初始值的为默认值 ；（此时后面类静态变量可能没有初始化完成，未执行到的静态变量也是取默认值）

(b)执行构造块

(c)执行构造函数

3.继续执行余下static语句

若存在继承关系，则先加载父类从上到下执行父类static修饰语句，然后再执行子类static语句。初始化类的时候，先初始化父类成员变量、构造块、构造函数；再执行子类成员变量、构造块、构造函数。

Output:

1:j i=0 n=0
2:构造块 i=1 n=1
3:t1 i=2 n=2
4:j i=3 n=3
5:构造块 i=4 n=4
6:t2 i=5 n=5
7:i i=6 n=6
8:静态块 i=7 n=99
----main start-------
9:j i=8 n=100
10:构造块 i=9 n=101
11:init i=10 n=102
------main end-------

关于static

1.static声明与初始化是两个不同操作

2.static声明在编译阶段已经确定了内存的位置

3.static修饰语句，会被编译器拼接成一个static块，并按照顺序从上到下执行

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞