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();   //312
        System.out.println("==========");
        Zi z = new Zi();    //312645
    }
}


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();    // 312
        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() 方法。