1. 基本介绍

代码化块又称为初始化块,属于类中的成员[即是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
但和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时，或创建对象时隐式调用。

2. 基本语法

[修饰符]{
    代码
};

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

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

1) 相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作
2) 应用场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中提高代码的重用性
3) 代码块的快速入门

public class CodeBlock01 {
    public static void main(String[] args) {
        new Movie("乱世佳人");
        System.out.println("=============================");
        new Movie("海上钢琴师", 100, "Giuseppe Tornatore");
    }
}

class Movie {
    private String name;
    private double price;
    private String director;

    //3个构造器->重载
    //1.下面三个构造器都有相同的语句
    //2.这样代码看起来有些冗余
    //3.这时可以把相同的语句放到一个代码块中即可
    //4.这样不管调用哪个构造器，创建对象，都会先调用代码块的内容
    //5.代码块的调用优先于构造器
    {
        System.out.println("电影屏幕打开了...");
        System.out.println("广告开始了...");
        System.out.println("电影正式开播了...");
    }
    public Movie(String name) {
        System.out.println("Movie(String name) 被调用了...");
        this.name = name;
    }

    public Movie(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public Movie(String name, double price, String director) {
        System.out.println("Movie(String name, double price, String director) 被调用了");
        this.name = name;
        this.price = price;
        this.director = director;
    }
}

在这里插入图片描述

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

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

2) 类什么时候被加载
①创建对象实例时(new)
②创建子类对象实例，父类也会被加载
③使用类的静态成员时(静态属性，静态方法)

案例演示：A类extends B类的静态块

public class CodeBlockDetail01 {
    public static void main(String[] args) {

        //类被加载的情况举例：
        //1.创建对象实例(new)
        //AA aa = new AA();
        //2.创建子类对象实例，父类也会被加载，而且父类先被加载，子类后被加载
        AA aa2 = new AA();
        //3.使用类的静态成员时(静态属性、静态方法)
        System.out.println(Cat.n1);
    }
}

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

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

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

class Cat extends Animal {

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

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

在这里插入图片描述

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

    //static代码块，是在类加载时被执行的，而且只会执行一次
    DD dd1 = new DD();
    DD dd2 = new DD();
    
class DD {
    //静态代码块
    static {
        System.out.println("DD 的静态代码块1被执行...");
    }
}

在这里插入图片描述

    DD dd1 = new DD();
    DD dd2 = new DD();
    
class DD {
    //静态代码块
    static {
        System.out.println("DD 的静态代码块1被执行...");
    }

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

在这里插入图片描述

    System.out.println(DD.name);

class DD {
    
    public static String name = "xdr";
    //静态代码块
    static {
        System.out.println("DD 的静态代码块1被执行...");
    }

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

在这里插入图片描述

小结:

1.static代码块是类加载时执行，只会执行一次。
2.普通代码块是在创建对象时调用的，创建一次，调用一次。

4) 创建一个对象时，在一个类调用顺序是：
①调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)

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

    }
}

class A {
    //静态属性初始化
    private static int n1 = getN1();

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

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

在这里插入图片描述

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

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

    }
}

class A {

    {
        System.out.println("A普通代码块1...");
    }

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

    private static int n1 = getN1();

    private int n2 = getN2();

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


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

在这里插入图片描述

③调用构造方法。

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

    }
}

class A {

    {
        System.out.println("A普通代码块1...");
    }

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

    private static int n1 = getN1();

    private int n2 = getN2();

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


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

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

}

在这里插入图片描述

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

class A {
    public A() {//构造器
    //这里有隐藏的执行要求
    //(1)super();
    //(2)调用普通代码块
}

举例：

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

class AAA {//父类 Object
    {
        System.out.println("AAA的普通代码块...");
    }

    //(1)super();
    //(2)调用本类的普通代码块
    public AAA() {
        System.out.println("AAA()构造器被调用...");
    }

}

class BBB extends AAA{

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

    public BBB() {
        //(1)super();
        //(2)调用本类的普通代码块
        System.out.println("BBB()构造器被调用...");
    }
}

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

class AAA {//父类 Object
    {
        System.out.println("AAA的普通代码块...");
    }

    //(1)super();
    //(2)调用本类的普通代码块
    public AAA() {
        System.out.println("AAA()构造器被调用...");
    }

}

class BBB extends AAA{

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

    public BBB() {
        //(1)super();
        //(2)调用本类的普通代码块
        System.out.println("BBB()构造器被调用...");
    }
}

在这里插入图片描述

看一下创建一个子类对象时(继承关系)，他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：

①父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
②子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
③父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
④父类的构造方法
⑤子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
⑥子类的构造方法

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

5. 练习

题 1：下面的代码输出什么？

public class CodeBlockExercise01 {
    public static void main(String[] args) {
        System.out.println("total" + Person.total);
        System.out.println("total" + Person.total);
    }
}
class Person {
    public static int total;

    static {
        total = 100;
        System.out.println("in static block");
    }
}

在这里插入图片描述

题 2：下面的代码输出什么？

public class CodeBlockExercise02 {
}

class Sample {
    Sample(String s) {
        System.out.println(s);
    }

    Sample() {
        System.out.println("Sample默认构造函数被调用");
    }
}

class Test {
    Sample sam1 = new Sample("sam1成员初始化");
    static Sample sam = new Sample("静态成员sam初始化 ");

    static {
        System.out.println("static块执行");
        if (sam == null) System.out.println("sam is null");
    }

    Test()//构造器
    {
        System.out.println("Test默认构造函数被调用");
    }

    //主方法
    public static void main(String[] args) {
        Test a = new Test();//无参构造器
    }

}

在这里插入图片描述

【JavaSE】代码块的基本使用

1. 基本介绍

2. 基本语法

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

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

5. 练习

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

【JavaSE】代码块的基本使用

1. 基本介绍

2. 基本语法

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

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

5. 练习

热门文章

最新文章

相关电子书