构造器的执行顺序

1,在没有静态块的情况下，子类的对象创建时，父类的无参构造器-->子类的构造器（产生对象的构造器，如果

是无参则执行的是无参构造器，如果执行的是有参则执行的有参构造器）

现在的父类中只有两个构造器：

 
 
 
    
  
  
  
  1. Father.java  
    2. 
  
  
  
  2.  Father {  
    3. 
  
  
  
  3.     public Father(){  
    4. 
  
  
  
  4.         System.out.println("我是父类的无参构造器");  
    5. 
  
  
  
  5.     }  
    6. 
  
  
  
  6.        
    7. 
  
  
  
  7.     public Father(String username){  
    8. 
  
  
  
  8.         System.out.println("我是父类有参构造器，传过来的参数是+"+username);  
    9. 
  
  
  
  9.     }  
    10. 
  
  
  
  10. public class SonDemo extends Father{  
    11. 
  
  
  
  11.    
    12. 
  
  
  
  12.     public SonDemo(){  
    13. 
  
  
  
  13.         System.out.println("我是--子类--的无参构造器");  
    14. 
  
  
  
  14.     }  
    15. 
  
  
  
  15.     public SonDemo(String username){  
    16. 
  
  
  
  16.         System.out.println("我是子类的有参构造器,参数是"+username);  
    17. 
  
  
  
  17.     }  
    18. 
  
  
  
  18.        
    19. 
  
  
  
  19.     public void sys(){  
    20. 
  
  
  
  20.         System.out.println("我是子类的sys方法");  
    21. 
  
  
  
  21.     }  
    22. 
  
  
  
  22.        
    23. 
  
  
  
  23.     public static void main(String[] args) {  
    24. 
  
  
  
  24.         //里面的内容在下面有说明  
    25. 
  
  
  
  25.     }  
    26. 
  
  
  
  26.        
    27. 
  
  
  
  27.        
    28. 
  
  
  
  28.        
    29. 
  
  
  
  29. } 
    30.

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

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

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

我是父类的无参构造器

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

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

SonDemo的main方法中加入

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

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

我是父类的无参构造器

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

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

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

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

SonDemo的main方法中加入

我是父类的无参构造器

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

我是父类的无参构造器

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

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

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

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

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

①程序的结果：

father static 

sonDemo static 

我是父类的无参构造器 

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

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

然后执行构造器。

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

打印结果：

father static 

sonDemo static 

我是父类的无参构造器

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

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

当前名称：构造器的执行顺序
URL地址：http://www.shufengxianlan.com/qtweb/news40/441090.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站内链知识

同城分类信息

成都网站制作　　 　定制网站设计　　 　营销型网站　　 　网站空间　　 　画册设计制作　　 　成都企业网站建设　　 　广安网站建设　　 　成都定制网站建设　　 　java虚拟主机　　 　成都宣传画册设计　　 　标志设计　　 　电信内江机房　　 　香港云服务器租用　　 　旅游网站建设方案　　 　消防维保　　 　云服务器香港　　 　宣威网站建设　　 　网络整合营销　　 　做网站　　 　黔盛装饰