03.java面向对象高级-代码块

03.java面向对象高级-代码块

1.代码块基本介绍

​ 代码化块又称为初始化块，属于类中的成员【即 是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过{} 包围起来。

​ 但和方法名不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显示调用

2.基本语法

[修饰符] {
方法体
};

注意:

1. 修饰符可选（可以有可以没有）, 要写的话, 也只能写static
2. 代码块分为两类,使用static修饰的叫静态代码块,没有static的, 叫普通代码块
3. 逻辑语句可以为任何逻辑语句(输入、输出、方法调用、循环、判断)
4. ; 号可以写上，也可以省略

3.代码块的好处和案例演示

1. 相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作
2. 如果多个构造器中都有重复语句，可以抽取到初始化块中，提高代码的重用性

案例：

package com.yzjedu.codeblock_;

/**
 * 代码块快速入门
 **/
public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie01 = new Movie("星际穿越");
        System.out.println("===========================");
        Movie movie02 = new Movie("绣春刀", 100, "张震");
    }
}
class Movie {
    private String name;
    private double price;
    private String director;

    //三个构造器 - 重载
    //1. 下面三个构造器都有相同的语句
    //2. 代码比较冗长
    //3. 这时我们可以把相同的语句,放入一个代码块中
    //4. 这样当我们不管调用那个构造器都会先调用代码块
    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    }
    public Movie(String name) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正式开始...");
        System.out.println("public Movie(String name)被调用");
        this.name = name;
    }

    public Movie(String name, double price) {
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正式开始...");
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        System.out.println(" public Movie(String name, double price, String director)被调用");
//        System.out.println("电影屏幕打开...");
//        System.out.println("广告开始...");
//        System.out.println("电影正式开始...");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

4. 代码块的使用注意事项和细节讨论

1. 静态代码块

​ static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是代码块，没创建一个对象就执行。

2. 类什么时候被加载【重要】

1. 创建对象实例时（new）
2. 创建子类对象实例时，父类也会被加载
3. 使用类的静态成员时（静态属性, 静态方法）

案例：

/**
 * 代码块使用细节
 **/
public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类被加载的情况举例
        //1. 创建对象实例时(new)
        AA aa = new AA();
        //2. 创建子类对象时，父类也会被加载,而且父类先被加载，子类后被加载
        AA aa1 = new AA();
        //3. 使用类的静态成员时(静态属性.静态方法)
        System.out.println(Cat.n1);
    }
}

class Cat {
    public static int n1 = 100;//静态属性

    //静态代码块
    static {
        System.out.println("Cat 的静态代码块被调用...");
    }
}

class BB {
    //静态代码块
    static {
        System.out.println("BB 的静态代码1被执行");
    }
}

class AA extends BB {

    static {//静态代码块
        System.out.println("AA 静态代码块1被执行 ");
    }
}

3. 普通代码块

1. 普通代码块创建对象实例时，会被隐式调用。被创建一次就调用一次
2. 如果是使用类的静态成员时，普通代码块并不会执行。

4. 创建一个对象时，在一个类 调用的顺序是：（重点、难点）

1. 调用静态代码块和静态属性初始化（注意：静态代码块和静态代码属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，测按他们定义的顺序使用）
2. 调用普通代码块和普通的代码属性初始化（注意：普通代码块和普通属性初始化，则按他们定义的顺序调用）
3. 调用构造方法。

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
        //1. 按照顺序是先输出getN1()被调用... 2.A 静态代码块01
        //3. getN2()被调用 4.普通代码块
        //扩展一下:最后才会调用构造器
    }
}

class A {
    private int n2 = getN2();
    {//普通代码块
        System.out.println("普通代码块被调用");
    }
    private static int n1 = getN1();
    static {
        System.out.println("A 静态代码块01");
    }

    public static int getN1() {
        System.out.println("getN1()被调用...");
        return 1000;
    }，
    public int getN2() {//普通方法
        System.out.println("getN2()被调用...");
        return 200;
    }

    public A() {
        System.out.println("无参构造器被调用...");
    }
}

5. 构造器补充

​ 构造器最前面其实隐含了 super() 和调用普通代码块. 静态相关的代码块,属性初始化,在类加载时就执行完毕, 因此是优先于构造器和普通代码块执行的

class A {
    public A() {
        //这里有隐藏的执行要求
        super();//在前面继承章节有讲解
        //调用普通代码块
        System.out.println("ok");
    }
}

6. 我们看一下创建一个子类时（继承关系），他们的静态代码块，静态初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下（很重要）

1. 父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
2. 子类的静态代码开和静态属性（优先级一样，按定义顺序执行）
3. 父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
4. 父类的构造方法
5. 子类的普通代码块和普通的属性初始化（优先级一样，按定义顺序执行）
6. 子类的构造方法

顺序为：1-2-3-4-5-6

演示：

public class CodeBlockDetail04 {
    public static void main(String[] args) {
        new B02();
    }
}

class A02 { //父类
    private static int n1 = getVal01();

    static {
        System.out.println("A02 的一个静态代码块..");//(2)
    }

    {
        System.out.println("A02 的第一个普通代码块..");//(5)
    }

    public int n3 = getVal02();//普通属性的初始化

    public static int getVal01() {
        System.out.println("getVal01");//(1)
        return 10;
    }

    public int getVal02() {
        System.out.println("getVal02");//(6)
        return 10;
    }

    public A02() {//构造器
        //隐藏
        //super()
        //普通代码和普通属性的初始化...... System.out.println("A02 的构造器");//(7)
    }
}

class B02 extends A02 { //
    private static int n3 = getVal03();

    static {
        System.out.println("B02 的一个静态代码块..");//(4)
    }

    public int n5 = getVal04();

    {
        System.out.println("B02 的第一个普通代码块..");//(9)
    }

    public static int getVal03() {
        System.out.println("getVal03");//(3)
        return 10;
    }

    public int getVal04() {
        System.out.println("getVal04");//(8)
        return 10;
    }
}

将代码复制idea，运行后，查看执行情况

备注：

​ 静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员。