qileilove

blog已经转移至github,大家请访问 http://qaseven.github.io/

构造器的执行顺序

 1、在没有静态块的情况下,子类的对象创建时,父类的无参构造器-->子类的构造器(产生对象的构造器,如果是无参则执行的是无参构造器,如果执行的是有参则执行的有参构造器)。现在的父类中只有两个构造器:
  1. Father.java  
  2.  Father {  
  3.     public Father(){  
  4.         System.out.println("我是父类的无参构造器");  
  5.     }  
  6.        
  7.     public Father(String username){  
  8.         System.out.println("我是父类有参构造器,传过来的参数是+"+username);  
  9.     }  
  10. public class SonDemo extends Father{  
  11.    
  12.     public SonDemo(){  
  13.         System.out.println("我是--子类--的无参构造器");  
  14.     }  
  15.     public SonDemo(String username){  
  16.         System.out.println("我是子类的有参构造器,参数是"+username);  
  17.     }  
  18.        
  19.     public void sys(){  
  20.         System.out.println("我是子类的sys方法");  
  21.     }  
  22.        
  23.     public static void main(String[] args) {  
  24.         //里面的内容在下面有说明 
  25.     }  
  26.        
  27.        
  28.        
  29. }

  ① 子类使用无参构造器创建对象:

  在SonDemo 的main方法中加入创建对象的代码:

  1. SonDemo son = new SonDemo();  
  2.        
  3. }

  我是父类的无参构造器

  我是--子类--的无参构造器

  ② 子类使用有参构造器创建对象:

  SonDemo的main方法中加入

SonDemo son = new SonDemo("than you ma");

  那么控制台打印的结果是:

  我是父类的无参构造器

  我是子类的有参构造器,参数是than you ma

  也就是说在子类调用无参构造器创建对象的时候,在执行它自己的有参构造器之前首先执行父类的无参构造器。

  ③ 在子类中创建父类的对象,使用无参

  1. SonDemo son = new SonDemo("than you ma");  
  2. Father ff = new Father();

  SonDemo的main方法中加入

  我是父类的无参构造器

  我是--子类--的无参构造器

  我是父类的无参构造器

  调用了父类的无参构造器,有参的创建对象调用的是有参构造器。

  总结:在创建子类对象的时候,首先会调用父类的构造器,让后在调用子类相应的构造器创建对象,在子类创建父类对象时,就是直接调用父类自己相应的构造器。

2、如果在子类和父类中存在静态块;执行顺序有会是怎么样的了?

  答,静态块会在构造器之前运行。不管是子类还是父类。创建一个对象的时候,会首先加载它的静态块。

  1. Father.java  
  2. public class Father {  
  3.    
  4.     //静态块  
  5.     static{  
  6.         System.out.println("father  static ");  
  7.     }  
  8.        
  9.     public Father(){  
  10.         System.out.println("我是父类的无参构造器");  
  11.     }  
  12.        
  13.     public Father(String username){  
  14.         System.out.println("我是父类有参构造器,传过来的参数是+"+username);  
  15.     }  
  16. }  
  17.    
  18. SonDemo.java  
  19. public class SonDemo extends Father{  
  20.     //静态块  
  21.     static{  
  22.         System.out.println("sonDemo static ");  
  23.     }  
  24.        
  25.     public SonDemo(){  
  26.         System.out.println("我是--子类--的无参构造器");  
  27.     }  
  28.     public SonDemo(String username){  
  29.         System.out.println("我是子类的有参构造器,参数是"+username);  
  30.     }  
  31.        
  32.     public void sys(){  
  33.         System.out.println("我是子类的sys方法");  
  34.     }  
  35.        
  36.     public static void main(String[] args) {  
  37.         SonDemo son = new SonDemo();  
  38.     }  
  39. }

  ① 程序的结果:

father static
sonDemo static
我是父类的无参构造器
我是--子类--的无参构造器

  因为在创建子类对象之前:会创建父类的一个对象,而静态块会在main之前被加载,所以两个类的静态块首先执行。

  然后执行构造器。

  ② 如果在子类中的main中只创建父类的对象结果是怎么样的呢?

  打印结果:

father static
sonDemo static
我是父类的无参构造器

  为什么子类的静态块会被加载了?是因为我们是在SonDemo中测试,如果在其他类中测试就不会打印。

  总结:我们说了这么多就是重要的一点。静态块会在构造器器之前执行。

posted on 2012-05-18 09:41 顺其自然EVO 阅读(86) 评论(0)  编辑  收藏


只有注册用户登录后才能发表评论。


网站导航:
 
<2012年5月>
293012345
6789101112
13141516171819
20212223242526
272829303112
3456789

导航

统计

常用链接

留言簿(54)

随笔分类

随笔档案

文章分类

文章档案

搜索

最新评论

阅读排行榜

评论排行榜