构造器的执行顺序

开发 后端
在没有静态块的情况下,子类的对象创建时,父类的无参构造器-->子类的构造器(产生对象的构造器,如果 是无参则执行的是无参构造器,如果执行的是有参则执行的有参构造器,详细请看下文

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.        

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

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

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

我是父类的无参构造器

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

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

SonDemo的main方法中加入

  1. 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.     }  

①程序的结果:

father static 

sonDemo static 

我是父类的无参构造器 

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

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

然后执行构造器。

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

打印结果:

father static 

sonDemo static 

我是父类的无参构造器

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

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

原文链接:http://www.cnblogs.com/pengqinping/archive/2012/05/14/2498892.html

【编辑推荐】

  1. Java端通过CXF调用.NET端服务
  2. Java线程池的原理及几类线程池的介绍
  3. Java中的异常对程序效率有无影响
  4. Java简单的网络爬虫实现
  5. Java调用SQL Server的存储过程详解
责任编辑:林师授 来源: 彭sir的博客
相关推荐

2012-02-27 14:09:00

Java

2009-07-21 12:35:00

Scala从构造器

2022-01-21 08:50:15

Promise任务队列前端

2022-01-04 19:33:03

Java构造器调用

2024-10-11 17:13:14

SQL数据库查询数据库

2019-11-06 09:30:35

SQL查询语句数据库

2010-04-16 09:27:18

Ocacle执行计划

2021-07-28 07:22:40

SQL顺序Hive

2009-07-17 17:41:41

SwingWorker

2024-11-07 12:37:17

2009-07-03 16:33:13

Tapestry函数执

2009-11-10 16:00:05

Oracle执行计划

2010-09-03 14:47:50

SQLSELECT语句

2011-05-16 10:35:02

jQuery

2021-09-26 09:59:14

MYSQL开发数据库

2010-08-27 13:07:00

CSS规则

2022-05-10 08:47:00

JMeter作用域执行顺序

2022-02-16 13:46:40

Spring Aop代码注解

2020-10-16 09:40:18

顺序Spring AOPHTTP

2019-10-22 08:45:07

Java构造器编程语言
点赞
收藏

51CTO技术栈公众号