1. class ClassLoad{
   
2.         static int number = 1;//静态变量(类变量)
   
3.         int xmember = 7;//成员变量
   
4.         ClassLoad(){
   
5.                 System.out.println("构造函数运行了"+number+xmember);
   
6.         }
   
7.         static{
   
8.                 System.out.println("静态代码块运行了"+number);//既然能调用说明静态变量先入内存
   
9.                 //System.out.println(xmember);//编译失败说明成员变量还未初始化
   
10.         }
    
11.         {
    
12.                 System.out.println("构造代码块运行了"+number+xmember);
    
13.         }
    
14.         public static void show(){
    
15.                 number = number+5;//说明了什么？
    
16.         }
    
17. }
    
18. public class  Client{
    
19.         public static void main(String[] args){
    
20.                 ClassLoad.show();
    
21.                 System.out.println(ClassLoad.number);
    
22.                 ClassLoad t2 = new ClassLoad();               
    
23.         }
    
24. }

复制代码

问题1---顺序是这样吗？：静态变量——>静态块——>成员变量——>构造代码块——>构造函数
问题2：  静态函数在哪？

顺序不是这样的，应该是静态块先执行，然后再执行静态变量啊。（静态块——>静态变量）静态块是随着类的加载而执行的，并且只能执行一次。

静态块——>静态变量——>成员变量——>构造方法
可以那下面的方法来证明一下

1. public class StaticDemo {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         static String s = "静态变量";
   
7.        
   
8.         static{
   
9.                
   
10.                 System.out.println("静态代码块");
    
11.         }
    
12.         public static void main(String[] args) {
    
13.                 // TODO Auto-generated method stub
    
14.                 System.out.println(s);
    
15.                 new De();
    
16.                
    
17.                
    
18.         }
    
19. 
    
20. }
    
21. class De{
    
22.          private String str;
    
23.         De(){
    
24.                 str ="成员变量";
    
25.                 System.out.println(str);
    
26.                
    
27.                 System.out.println("构造函数");
    
28.         }
    
29.         {
    
30.                
    
31.                
    
32.                 System.out.println("构造代码块");
    
33.         }
    
34.        
    
35. }

复制代码

这个也可以用LZ自己的代码证明 我改了下

1. class ClassLoad{
   
2.         static int number = 1;//静态变量(类变量)
   
3.         int xmember = 7;//成员变量
   
4.         
   
5.         ClassLoad(){
   
6.                 System.out.println("构造函数运行了");
   
7.         }
   
8.         static{
   
9.                 System.out.println("静态代码块运行了");//既然能调用说明静态变量先入内存
   
10.               show();
    
11.         }
    
12.         {
    
13.                 System.out.println("构造代码块运行了");
    
14.         }
    
15.         public static void show(){
    
16.                System.out.println("静态函数运行了");
    
17.                
    
18.         }
    
19.         
    
20. }
    
21. public class  StaticDemo{
    
22.         public static void main(String[] args){
    
23.                 new ClassLoad();
    
24.                
    
25.               
    
26.         }
    
27. }

复制代码

2 静态函数就是show方法

kira 发表于 2014-2-12 17:50
静态块——>静态变量——>成员变量——>构造方法
可以那下面的方法来证明一下

你的代码无法证明！  谢谢！

tangxiaobo1991 发表于 2014-2-12 16:02
顺序不是这样的，应该是静态块先执行，然后再执行静态变量啊。（静态块——>静态变量）静态块是随着类的加 ...

代码呢？ 用代码证明一下！

可以使用eclipse的调试视图看一下流程,DOS下显示结果为

静态方法和静态变量存储在静态方法区中，在类加载时静态方法和静态变量就已经被加载到静态方法区中。
关于运行顺序：静态代码块，静态变量，构造代码块 构造函数。