面向对象基础11（初始化块）

语法：

[修饰符]{
    各种语句
}

初始化块是没有名字的

修饰符有且只有static

• 有static修饰的叫类初始化块（静态初始化块）；
• 没有static修饰的叫做实例初始化块（非静态初始化块）；

类中可有定义变量的语句，但不能有赋值语句；

• public class Block{
    int age = 2;
    String name;
    {
        name = "ggttnn"
    }
  }

实例初始化块（没有修饰符static）

实例初始化快是一个“假象”——一个类在编译之后，实例初始化快就会消失——

实例初始化快的所有代码会被还原到每个构造器的开始部分

举例：

public class Init {
    {
        System.out.println("假的实例初始化块");
        //在编译的时候，这句输出语句将自动出现在每个构造器的第一句
    }
    public Init() {
        System.out.println("无参数构造器");
    }
    public Init(String name) {
        System.out.println("有参数构造器" + name);
    }
}

在编译时，以上语句的作用等同于

public class Init {
    public Init() {
        System.out.println("假的实例初始化块");
        System.out.println("无参数构造器");
    }
    public Init(String name) {
        System.out.println("假的实例初始化块");
        System.out.println("有参数构造器" + name);
    }
}

在Test类中编译以后：

public class InitTest {
    public static void main(String[] args) {
        Init a=new Init();
        Init b=new Init("233");
    }
}
/*
假的实例初始化块
无参数构造器
假的实例初始化块
有参数构造器233
*/

作用——将多个构造器的开始的相同的代码可以提取到实例初始化块进行管理

执行条件——只有程序调用构造器创建对象，程序总会先执行初始化块的语句

定义实例变量时指定的初始值也是“假象”

——指定的初始值在编译之后会变成构造器所有代码之前的一条赋值语句

举例：

public class Init {
    {
        //在编译的时候，这句赋值语句将自动出现在每个构造器的第一句
        age = 20;
    }
    int age = 2;//此处源代码的排列顺序影响age最终的赋值
    public Init() {
        System.out.println("无参数构造器" + age);
    }
    public Init(String name) {
        System.out.println("有参数构造器" + age);
    }
}

上述代码等同于：

public class Init {
    int age;
    public Init() {
        age = 20;
        age = 2;
        System.out.println("无参数构造器" + age);
    }
    public Init(String name) {
        age = 20;
        age = 2;
        System.out.println("有参数构造器" + age);
    }
}

固编译执行之后得：

public class InitTest {
    public static void main(String[] args) {
        Init a = new Init();
        Init b = new Init("233");
    }
}
/*
无参数构造器2
有参数构造器2
*/

综上所述，实例初始化块的语句要还原到所有的构造器代码之前，

定义变量的初始值也要还原到构造器的所有代码之前，

二者的先后顺序取决于其在源代码中的先后顺序。

类初始化块（有修饰符static）

负责对类进行初始化——

当程序第一次主动使用该类的时候，系统会自动为该类分配空间，并对其初始化（调用类初始化块）

只要用户使用该类，基本都算主动使用类——出了仅仅使用类声明变量。

对比：

同理，定义类变量时所指定的初始值，也是“假象”。

——指定的初始值。编译之后就变成了类初始化中的第一条赋值语句。

但到底是在类初始化代码前还是在其后，取决于他在源代码中的先后顺序。

举例：

public class StaticInit {
    static int age = 30;
    //类初始化块
    static {
        age = 300;
        System.out.println("类初始化块"+age);
    }
}

public class StaticInitTest {
    public static void main(String[] args) {
        StaticInit a;//单纯的声明变量不会执行类初始化快
        StaticInit a=new StaticInit();
        System.out.println(StaticInit.age);
    }
}
/*
类初始化块300
300 
*/

可见，类初始化只执行一次。

思考：

public class Base {
    static {
        System.out.println("Base的类初始化块");
    }
    public Base() {
        System.out.println("无参构造器");
    }
    public Base(String name) {
        System.out.println("有参构造器");
    }
}
class Mid extends Base {
    public Mid(int age) {
        this();
        System.out.println("Mid的int构造器");
    }
    public Mid() {
        super("just");
        System.out.println("Mid的无参构造器");
    }
}
class Sub extends Mid {
    public Sub() {
        System.out.println("Sub的无参数构造器");
    }
    public Sub(double a) {
        System.out.println("Sub的double构造器");
    }
}

public class BaseTest {
    public static void main(String[] args) {
        new Sub(3.1);
        new Sub(4.2);
    }
}
/*
Base的类初始化块
有参构造器
Mid的无参构造器
Sub的double构造器
有参构造器
Mid的无参构造器
Sub的double构造器
*/

子类的初始化必然要调用父类的构造器，一直到Object的构造器（祖宗类）。

• 初始化任何类之前，一定先从Object类开始初始化，然后依次初始化该类的父类以及所有祖先类，最后初始化该类
• 创建任何对象时，一定是先从Object开始执行，执行完它所有祖先类的构造器，最后执行他自己的构造器