阳哥查收哦

学习学习

dhysh5512176 发表于 2014-11-28 14:15
阳哥查收哦

这一题的目的是明白一个对象初始化的时候，静态代码块、代码块、构造函数等的执行顺序。

嗯嗯，真去拿够技术分

已经完成！！！！

骑着乌龟去旅行 发表于 2014-11-28 21:52
已经完成！！！！

1. void a(){
   
2.                 System.out.println("代码块"+" ");
   
3.         }
   
4.        

复制代码

这叫方法，不叫代码块。代码块是{};执行的顺序因此也是不对的。你一定仔细读懂题意。不然做这些题反而会让你进入误区。

我就是这么标准的十五个字的回复

看看。。。

回帖领题

Demo.zip (594 Bytes, 下载次数: 1)

2014-11-30 15:29 上传

点击文件名下载附件
阅读权限: 200

源码注释中带有结果分析。

领题！！！

邮件已到！！！

lwh316658735 发表于 2014-12-1 01:16
邮件已到！！！

1. package test;
   
2. 
   
3. public class StaticDemo {
   
4. 
   
5.         /**
   
6.          * @param args
   
7.          */
   
8.         static int x=9;
   
9.         {
   
10.                 System.out.println("C");
    
11.         }
    
12.         static{
    
13.                 System.out.println("B");
    
14.         }
    
15.         StaticDemo(){
    
16.                 System.out.println("A");
    
17.         }
    
18.        
    
19.         public static void main(String[] args) {
    
20.                 // TODO Auto-generated method stub
    
21.                 new StaticDemo();
    
22.                 //测试静态代码块执行的次数
    
23.                 new StaticDemo();
    
24.                
    
25.                 StaticDemo sd=new StaticDemo();
    
26. 
    
27.                 System.out.println(StaticDemo.x);
    
28.                 //静态成员变量和静态代码块一样在该内被加载时就加载进入方法区的静态区
    
29.         }
    
30. 
    
31. }
    
32. //静态代码块在类加载时就加载进内存中了，所以只运行一次。
    
33. //而代码块在对象进入内存中与优先于构造方法执行。

复制代码

你这里没有出现代码块，代码块是单独的{}里面的代码。

as604049322 发表于 2014-11-30 15:30
源码注释中带有结果分析。

1. 
   
2. public class Demo {
   
3. 
   
4.     public static void main(String[] args){
   
5.           // new Test();
   
6.            System.out.println("var="+Test.getvar());
   
7.            System.out.println("var="+Test.getvar());
   
8.     }
   
9.         /*运行结果为：静态代码块！var=0
   
10.                                 代码块！var=1
    
11.                                 构造函数！var=1
    
12.                                 var=1
    
13.                                 var=1
    
14.         而将new Test();注释后，运行结果为：
    
15.         静态代码块！var=0
    
16.         var=1
    
17.         var=1
    
18.         从而证明：初始化对象的时候的执行顺序为静态代码块、代码块、构造函数。
    
19.         直接用类名调用该类的静态变量时的执行的顺序为只执行静态代码块或不执行，若内存中不存在Test类则执行一次静态代码块进行初始化，否则不执行。
    
20.        
    
21.         */
    
22. }
    
23. 
    
24. class Test {
    
25.         private static int var=0;
    
26.         Test(){
    
27.                 System.out.println("构造函数！var="+var);
    
28.         }
    
29.         {
    
30.                 System.out.println("代码块！var="+var);
    
31.         }
    
32.         static{
    
33.                 System.out.println("静态代码块！var="+var);
    
34.                 var++;
    
35.         }
    
36.         public static int getvar(){
    
37.                 return var;
    
38.         }
    
39. }

复制代码

还可以。

拿技术分！！！！！！！！！！！！！！！！！！！！！

look                  

做老题  得一份 哈哈  来了

做老题  得技术分 开始  阳哥

mmppp 发表于 2014-12-5 16:50
做老题  得技术分 开始  阳哥

1. 结论：在直接初始化对象时，执行顺序为： 静态代码块   构造代码块   构造函数。
   
2.       在用类名调用静态变量时，执行顺序为  ：  构造代码块  构造函数   静态代码块  静态变量

复制代码

第一条规律是正确的，第二条规律是不正确的。希望你能再好好琢磨一下。

sorry  阳哥  刚才脑子短路了 哈哈 类名调用静态变量我还初始化一下对象。。。。