Java 面向对象—非静态代码块

一、非静态代码块

　　1、声明格式

【修饰符】 class 类名 {
      {
             非静态代码块
       }
 }    

　　2、非静态代码块中的代码执行时机

　　　　（1）在"每次"创建对象的时候执行

　　　　（2）比构造方法早

　　　　Demo:

 class MyClass{
     private String str;

     public MyClass(){
         System.out.println("无参构造2");
     }
     public MyClass(String str){
         this.str = str;
         System.out.println("有参构造3");
     }

     {
         System.out.println("非静态代码块1");
     }
 }

　　　　运行结果：先执行非静态代码中输出"非静态代码块1"，然后执行无参构造方法输出"无参构造2"。

　　3、实例初始化过程

　　　　初始化过程：创建对象时，为对象进行初始化的操作

　　　　执行顺序：

① 为成员变量显示赋值

② 执行非静态代码块

③ 执行构造器

　　　　图解：

　　　　Java 编译器其实，会把这三个部分的代码，合成一个叫做 <init>(【形参列表】) 实例初始化方法。

　　　　即编译后的 .class 字节码文件中，是没有构造方法这个概念的。

　　　　<init>(【形参列表】) 实例初始化方法的代码就是由三个部分组成：

① 成员变量显示赋值的代码

② 非静态代码中的代码

③ 构造器中的代码

　　　　注意：

　　　　　　1、其中的 ① 和 ② 按顺序执行，而 ③ 一定是它们当中的最后执行的。

　　　　　　2、有几个构造器，就会有几个实例初始化方法。那么当创建对象的时候，调用对应的构造器时，其实执行的是对应的实例初始化方法 <init>(【...】)

二、继承中的非静态代码块

　　1、继承案例

　　　　先来看一个没有非静态的代码块的继承关系：

　　　　Demo：

 public class TestInit {
     public static void main(String[] args) {
          Father f = new Father();
          //执行父类的无参构造

          Son s = new Son();
          //先执行父类的无参构造，再执行子类的无参构造

          Son s2 = new Son("HelloWorld");
          //先执行父类的无参构造，再执行子类的有参构造1

          Son s3 = new Son("Java", 10);
          // 先执行父类的无参构造，再执行子类的有参构造1，然后再执行子类的有参构造2

     }
 }
 //父类
 class Father{
     public Father(){
         System.out.println("父类的无参构造");
     }
 }
 // 子类
 class Son extends Father{
     private String str;
     private int num;

     public Son(){
         //隐含了super();  子类的构造器中一定会调用父类的构造器，默认调用父类的无参构造
         System.out.println("子类的无参构造");
     }

     public Son(String str){
         //隐含了super()
         this.str = str;
         System.out.println("子类的有参构造1");
     }

     public Son(String str,int num){
         this(str);           //这里有this就不会有super了，然后调用本类中的构造方法
         this.num = num;
         System.out.println("子类的有参构造2");
     }
 }                

　　2、含有非静态代码块的继承关系

　　　　（1）先执行父类的实例初始化方法

　　　　　　它由三部分组成：

① 成员变量的显示赋值

② 非静态代码块

③ 构造方法

　　　　（2）再执行子类的实例初始化方法

　　　　　　它由三部分组成：

① 成员变量的显示赋值

② 非静态代码块

③ 构造方法

　　　　注意：

　　　　① super() 或 super(实参列表) 之前说的是调用父类的构造器，其实是调用父类对应的实例初始化方法

　　　　② super() 或 super(实参列表) 之前说的是在子类构造器的首行，其实是在子类实例初始化方法的首行，所以会先完成父类的初始化，再进行子类的初始化。

　　　　Demo：

 public class TestInit {
     public static void main(String[] args) {
         Fu f = new Fu();   //
         System.out.println("==========");
         Zi z = new Zi();    //
     }
 }

 class Fu{
     private String strFu = assignFu();
     {
         System.out.println("(1)父类的非静态代码块");
     }
     public Fu(){
         System.out.println("(2)父类的无参构造");
     }
     public String assignFu(){
         System.out.println("(3)父类的assignFu()");
         return "fu";
     }
 }
 class Zi extends Fu{
     private String strZi = assignZi();
     {
         System.out.println("(4)子类的非静态代码块");
     }
     public Zi(){
         //super()  ==>调用父类的实例初始化方法，而且它在子类实例初始化方法的首行
         System.out.println("(5)子类的无参构造");
     }

     public  String assignZi(){
         System.out.println("(6)子类的assignZi()");
         return "zi";
     }
 }

　　　运行结果：

　　　　　

　　    图解：

　　

　　3、含有非静态代码块的重写继承关系

　　　　Demo：

 public class TestInit {
     public static void main(String[] args) {
         Ba b = new Ba();    //
         System.out.println("============");
         Er r = new Er();      //612645，因为子类重写了assign()

     }
 }
 class Ba{
     private String str = assign();
     {
         System.out.println("(1)父类的非静态代码块");
     }
     public Ba(){
         System.out.println("(2)父类的无参构造");
     }
     public String assign(){
         System.out.println("(3)父类的assign()");
         return "ba";
     }
 }
 class Er extends Ba{
     private String str = assign();
     {
         System.out.println("(4)子类的非静态代码块");
     }
     public Er(){
         //super()  ==>调用父类的实例初始化方法，而且它在子类实例初始化方法的首行
         System.out.println("(5)子类的无参构造");
     }

     public String assign(){
         System.out.println("(6)子类的assign()");
         return "er";
     }
 }

　　运行结果：

　　

　　图解：

　　注意：this在构造器中，在实例化初始化方法中，代表的是正在创建的对象，当创建子类对象时，因为子类重写的 assign()，那么执行是子类重写的 assign() 方法。