Java基础之：OOP——代码块

代码块又称初始化块，是类中的成员(即类的一部分)，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来，也是通过调用执行。

但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

基本语法

[修饰符]{

代码(方法体)

};

说明：

1. 修饰符可选是否添加，但只能添加static

2. 代码块分为两种，加了static的静态代码块，没加static的普通代码块

3. 逻辑语句可以是任何逻辑语句(输入、输出、方法调用、循环、判断等)

4. 结尾的“;”号可以不写，[建议不写]

代码块优点

代码块相当于另外一种形式的构造器(对构造器的补充机制)，可以作初始化的操作。

当构造器重载时，可以提取多个构造器重复执行的代码，放入代码块中。

简单案例

电影放映

public class CodeBlockTest02 {

    public static void main(String[] args) {

        new Movie();
        
        System.out.println("----------------");
        new Movie("唐人街探案3..");
        
        System.out.println("---------------");
        new Movie("我和我的祖国...", 80, "张艺谋");
    }

}

class Movie {
    
    private String name;
    private double price;
    private String director;
    
    //代码块
    {
        System.out.println("电影开始播放广告...");
        System.out.println("电影屏幕拉下来.");
        System.out.println("电影播放.");
    }
    
    public Movie() {
        
        
    }
    public Movie(String name) {
    
        this.name = name;
    }
    public Movie(String name, double price, String director) {
        
        
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

结果输出

代码块使用说明

1. static代码块又称静态代码块，静态代码块在类加载时就会执行且仅执行一次，和静态属性/静态方法相同。静态代码块的作用就是初始化类。

2. 普通的代码块，每声明一个对象执行一次普通代码块，所以我们又可以将普通代码块看成构造器的一部分。

3. 如果只使用类的静态成员，则不会执行普通代码块。因为只要不声明对象，普通代码块就不会执行。

什么时候类被加载：

1. 创建对象时： Person p = new Person();

2. 创建子类对象时，父类也会被加载：Student s = new Student(); (Student extends Person，Student和Person都会被加载)

3. 使用类的静态成员(静态属性，静态方法)时：Student.totalFee; (private static double totalFee)

创建对象时，类的调用顺序

1. 调用静态代码块和静态属性初始化(注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)

2. 调用普通代码块和普通属性的初始化(注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)

3. 调用构造方法。

构造方法(构造器) 的最前面其实隐含了 super()和 调用普通代码块。

class Person{
    public Person(){
        super();
        //调用普通代码块
        System.out.println("Person");
    }
}

静态相关的代码块，属性初始化，在类加载时，就执行完毕, 因此是优先于 构造器和普通代码块执行的。

静态代码块只能直接调用静态成员，普通代码块可以调用任意成员。(因为在静态代码块执行时，只有静态成员已经被加载了)

对象加载顺序案例

package codeBlock;

public class Extends_blockTest {

    public static void main(String[] args) {
        new C();
    }

}
class A{
    
    private String name = nameA();
    private static int age = ageA();
    
    static {
        System.out.println("A .... static Block");
    }
    
    {
        System.out.println("A .... ordinary Block");
    }
    
    public String nameA() {
        System.out.println("A .... ordinary Args");
        return "AAA";
    }
    
    public static int ageA() {
        System.out.println("A .... static Args");
        return 18;
    }

    public A() {
        System.out.println("A .... constructor");
    }
}

class B extends A{
    
    static {
        System.out.println("B .... static Block");
    }
    
    private String name = nameB();
    private static int age = ageB();
    

    {
        System.out.println("B .... ordinary Block");
    }
    
    public String nameB() {
        System.out.println("B .... ordinary Args");
        return "BBB";
    }
    
    public static int ageB() {
        System.out.println("B .... static Args");
        return 18;
    }

    public B() {
        System.out.println("B .... constructor");
    }
}

class C extends B{
    private String name = nameC();
    private static int age = ageC();
    
    static {
        System.out.println("C .... static Block");
    }
    
    {
        System.out.println("C .... ordinary Block");
    }
    
    public String nameC() {
        System.out.println("C .... ordinary Args");
        return "CCC";
    }
    
    public static int ageC() {
        System.out.println("C .... static Args");
        return 18;
    }

    public C() {
        System.out.println("C .... constructor");
    }

}

输出结果

A .... static Args

A .... static Block

B .... static Block

B .... static Args

C .... static Args

C .... static Block

A .... ordinary Args

A .... ordinary Block

A .... constructor

B .... ordinary Args

B .... ordinary Block

B .... constructor

C .... ordinary Args

C .... ordinary Block

C .... constructor