Java---面向对象编程---代码块

扶苏-su

625人浏览 · 2025-09-07 15:32:42

扶苏-su · 2025-09-07 15:32:42 发布

基本介绍

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

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

基本语法

[ 修饰符 ]{

代码

}; // ；可有可无

说明注意：

1）修饰符可选，要写的话，也只能写 static（即要么没修饰符要么加static）

2）代码块分为两类，使用 static 修饰的叫静态代码块，没有 static 修饰的，叫普通代码块/非静态代码块。

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

4）; （分号）可以写上，也可以省略

代码块的好处和案例演示

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

2）场景：如果多个构造器中都有重复的语句，可以抽取到代码块中，提高代码的复用性

3）代码块的快速入门

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

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

2）类什么时候被加载[ 重要！]

1.创建对象实例时(new)

package com.heima.Hello.CodeBlock_;

public class CodeBlockDetails {
    public static void main(String[] args) {
        // 类被加载的情况举例
        // 1.创建对象实例时
         AA aa = new AA();
        // 2.创建子类对象实例，父类也会被加载。而且，父类会现被加载，子类后被加载
        // BB bb = new BB();
        // 3.使用类的静态成员时(静态属性，静态方法)
        // System.out.println(Cat.a);

    }
}

class AA{

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

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

class Animal{
    static{
        System.out.println("Animal的代码块被执行...");
    }
}


class Cat extends Animal {
    public static int a = 999;
    static{
        System.out.println("Cat的静态代码块被执行...");
    }
}

2.创建子类对象实例，父类也会被加载

package com.heima.Hello.CodeBlock_;

public class CodeBlockDetails {
    public static void main(String[] args) {
        // 类被加载的情况举例
        // 1.创建对象实例时
        // AA aa = new AA();
        // 2.创建子类对象实例，父类也会被加载。而且，父类会现被加载，子类后被加载
         BB bb = new BB();
        // 3.使用类的静态成员时(静态属性，静态方法)
        // System.out.println(Cat.a);

    }
}

class AA{

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

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

class Animal{
    static{
        System.out.println("Animal的代码块被执行...");
    }
}


class Cat extends Animal {
    public static int a = 999;
    static{
        System.out.println("Cat的静态代码块被执行...");
    }
}

3.使用类的静态成员时（静态属性，静态方法）

package com.heima.Hello.CodeBlock_;

public class CodeBlockDetails {
    public static void main(String[] args) {
        // 类被加载的情况举例
        // 1.创建对象实例时
        // AA aa = new AA();
        // 2.创建子类对象实例，父类也会被加载。而且，父类会现被加载，子类后被加载
        // BB bb = new BB();
        // 3.使用类的静态成员时(静态属性，静态方法)
        System.out.println(Cat.a);
        // static 代码块在类加载时，只会被执行一次
        // DD dd1 = new DD();
        // DD dd2 = new DD();
        // EE ee1 = new EE();
        // EE ee2 = new EE();
    }
}

class EE{
    {
        System.out.println("EE的普通代码块被调用...");
    }
}
class AA{

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

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

class Animal{
    static{
        System.out.println("Animal的代码块被执行...");
    }
}


class Cat extends Animal {
    public static int a = 999;
    static{
        System.out.println("Cat的静态代码块被执行...");
    }
}

class DD{
    static{
        System.out.println("DD的代码块被执行...");
    }
}

案例演示：A类 extends B类的代码块

3）静态代码块只会调用一次，普通的代码块，在创建对象实例时，会被隐式的调用/被创建一次，就会被调用一次。静态代码块和普通代码块都有时，先调用静态代码块

4）如果只是使用类的静态成员时，普通代码块并不会执行，要创建对象才会被调用（可以这样理解：普通代码块是构造器的一种补充，构造器被调用了，它就会被调用）

静态代码块

package com.heima.Hello.CodeBlock_;

public class CodeBlockDetails {
    public static void main(String[] args) {
        // 类被加载的情况举例
        // 1.创建对象实例时
        // AA aa = new AA();
        // 2.创建子类对象实例，父类也会被加载。而且，父类会现被加载，子类后被加载
        // BB bb = new BB();
        // 3.使用类的静态成员时(静态属性，静态方法)
        // System.out.println(Cat.a);
        // static 代码块在类加载时，只会被执行一次
        DD dd1 = new DD();
        DD dd2 = new DD();
    }
}

class AA{

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

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

class Animal{
    static{
        System.out.println("Animal的代码块被执行...");
    }
}


class Cat extends Animal {
    public static int a = 999;
    static{
        System.out.println("Cat的静态代码块被执行...");
    }
}

class DD{
    static{
        System.out.println("DD的代码块被执行...");
    }
}

普通的代码块

package com.heima.Hello.CodeBlock_;

public class CodeBlockDetails {
    public static void main(String[] args) {
        // 类被加载的情况举例
        // 1.创建对象实例时
        // AA aa = new AA();
        // 2.创建子类对象实例，父类也会被加载。而且，父类会现被加载，子类后被加载
        // BB bb = new BB();
        // 3.使用类的静态成员时(静态属性，静态方法)
        // System.out.println(Cat.a);
        // static 代码块在类加载时，只会被执行一次
        // DD dd1 = new DD();
        // DD dd2 = new DD();
        EE ee1 = new EE();
        EE ee2 = new EE();
    }
}

class EE{
    {
        System.out.println("EE的普通代码块被调用...");
    }
}
class AA{

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

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

class Animal{
    static{
        System.out.println("Animal的代码块被执行...");
    }
}


class Cat extends Animal {
    public static int a = 999;
    static{
        System.out.println("Cat的静态代码块被执行...");
    }
}

class DD{
    static{
        System.out.println("DD的代码块被执行...");
    }
}

5）创建一个对象时，在一个类调用顺序是:(重点，难点)

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

package com.heima.Hello.CodeBlock_;

public class CodeBlockDetails02 {
    public static void main(String[] args) {
        A a = new A();
    }
}

class A{
    public static int n1 = getN1();

    static{
        System.out.println("A 静态代码块01");
    }

    public static int getN1(){
        System.out.println("getN1被调用...");
        return 100;
    }
}

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

3）调用构造方法

6）构造器的最前面其实隐含了 super()和调用普通代码块，新写一个类演示，静态相关的代码块，属性初始化，在类加载，就执行完毕，因此是优先于构造器和普通代码块执行的

package com.heima.Hello.CodeBlock_;

public class CodeBlockDetails03 {
    public static void main(String[] args) {
        new BBB();
    }
}

class AAA{
    
    {
        System.out.println("AAA  的普通代码块...");    
    }
    
    public AAA(){
        System.out.println("AAA()  构造器被调用...");
    }
}


class BBB extends AAA{
    {
        System.out.println("BBB  普通代码块");
    }

    public BBB(){
        // 隐藏了两部分
        // super();
        //调用本类的代码块
        System.out.println("BBB()  构造器被调用...");
    }
}