静态代码块，非静态代码块和构造方法执行顺序

2016-05-27 00:59 阅读 5,976 次 评论 0 条

一.摘要

子类继承父类，在子类和父类中都声明了静态代码块，非静态代码块和构造方法，在入口中初始化子类对象，执行的顺序如下图：

001-static-method-construct-execute

第一步：执行父类的静态代码块，执行子类的静态代码块

第二步：执行父类的非静态代码块，执行父类的构造方法

第三步：执行子类的非静态代码块，执行子类的构造方法

  1. package cn.teachcourse.temp;  
  2.   
  3. import android.util.Log;  
  4.   
  5. /** 
  6.  * Created by TeachCourse.cn on 2016/5/22 14:04. 
  7.  */  
  8. public class DemoA {  
  9.     private static final String TAG=DemoA.class.getName();  
  10.     /** 
  11.      * 静态代码块写法 
  12.      */  
  13.     static {  
  14.         Log.d(TAG,"父类的静态代码块。。。");  
  15.     }  
  16.   
  17.     /** 
  18.      * 构造方法的写法 
  19.      */  
  20.     public DemoA(){  
  21.        Log.d(TAG,"父类的构造方法。。。");  
  22.    }  
  23.     /** 
  24.      * 父类的非静态代码块 
  25.      */  
  26.     {  
  27.        Log.d(TAG,"父类的非静态代码块。。。");  
  28.     }  
  29.     /** 
  30.      * 父类的静态方法 
  31.      */  
  32.     public static void start(){  
  33.         Log.d(TAG,"父类的静态方法。。。");  
  34.     }  
  35.     /** 
  36.      * 父类的非静态方法 
  37.      */  
  38.     public void start(String msg){  
  39.         Log.d(TAG,"父类的非静态方法。。。");  
  40.     }  
  41. }  

DemoB继承DemoA重写父类的方法，需要注意如何不覆盖父类的方法，使用关键字super

  1. package cn.teachcourse.temp;  
  2.   
  3. import android.util.Log;  
  4.   
  5. /** 
  6.  * Created by TeachCourse.cn on 2016/5/22 14:08. 
  7.  */  
  8. public class DemoB extends DemoA {  
  9.     private static final String TAG=DemoB.class.getName();  
  10.     /** 
  11.      * 静态代码块写法 
  12.      */  
  13.     static {  
  14.         Log.d(TAG,"子类的静态代码块。。。");  
  15.     }  
  16.   
  17.     /** 
  18.      * 构造方法的写法 
  19.      */  
  20.     public DemoB(){  
  21.         Log.d(TAG,"子类的构造方法。。。");  
  22.     }  
  23.     /** 
  24.      * 父类的非静态代码块 
  25.      */  
  26.     {  
  27.         Log.d(TAG,"子类的非静态代码块。。。");  
  28.     }  
  29.     /** 
  30.      * 父类的静态方法 
  31.      */  
  32.     public static void start(){  
  33.         Log.d(TAG,"子类的静态方法。。。");  
  34.     }  
  35.     /** 
  36.      * 父类的非静态方法 
  37.      */  
  38.     @Override  
  39.     public void start(String msg){  
  40.         super.start(msg);  
  41.         Log.d(TAG,"子类的非静态方法。。。");  
  42.     }  
  43. }  

二.super关键字

super关键字表示“超级的”意思，在子类重写的方法中使用，表示不隐藏父类同方法名的方法，程序在调用子类的方法时，优先执行父类同方法名的方法，同时在子类的方法体中使用super关键字，可以在方法体代码前面或方法体代码后，效果都是优先执行父类方法体，再执行子类方法体，比如下面的代码：

  1. /** 
  2.      * 父类的非静态方法 
  3.      */  
  4. public void start(String msg){  
  5.         Log.d(TAG,"父类的非静态方法。。。");  
  6.     }  
  1. /** 
  2.      * 子类的非静态方法 
  3.      */  
  4.     @Override  
  5. public void start(String msg){  
  6.         super.start(msg);  
  7.         Log.d(TAG,"子类的非静态方法。。。");  
  8.     }  

Log输出的结果是：父类的非静态方法，子类的非静态方法，然后将super.start(msg)放在Log.d()后，打印的结果一样。事实证明，在子类方法体添加super关键字，优先执行父类的同名方法体。

如果在子类的同名方法中，不使用super关键字，程序执行子类同名的方法体，不执行父类同名方法，重写父类或接口方法时，这一步可以根据实际的需要进行方法的重写。

三.单一继承原则

什么是单一继承原则？单一继承原则表示一个子类只允许有一个父类，即只可以继承一个父类的属性和方法，但是可以有多重继承。多重继承的含义，就像儿子可以继承父亲的财产，同时也可以继承爷爷的财产，还可以继承曾爷爷的财产，甚至还可以再往上继承......程序在执行的时候，优先执行最顶层的类静态方法到每一级的静态方法，然后最顶层的非静态方法到每一层的非静态方法，最后执行最顶层的构造方法到每一层的构造方法。一个原则：静态方法——>非静态方法——>构造方法

你可能感兴趣的文章

来源：TeachCourse， 每周一次，深入学习Android教程，关注（QQ158#9359$239或公众号TeachCourse）
转载请注明出处： https://www.teachcourse.cn/1770.html ，谢谢支持！

资源分享

分类：Java基础 标签：
浅谈GC机制 浅谈GC机制
Easy WP SMTP 插件，wordpress万网主机smtp发邮件失败解决办法 Easy WP SMTP 插件，word
关于universal imageloader缓存你需要知道的秘密 关于universal imageloader缓存你
”Found 2 version of android-support-v4.jar in the dependency list“解决思路 ”Found 2 version of android-