代码块，执行顺序，类加载，创建对象

最新推荐文章于 2024-07-09 16:46:46 发布

枯寂麻辣

最新推荐文章于 2024-07-09 16:46:46 发布

阅读量558

点赞数

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_43669384/article/details/129991808

版权

代码块又称初始化块，属于类中的成员【即是类的一部分】，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来
和方法不同，没有方法名，没有返回值，没有参数，只有方法体，而且不用通过对象或类显示调用，而是加载类时，或创建对象时隐式调用。
基本语法
1. [修饰符]{代码}；
2. 注意说明：修饰符可选，要写的话只能写static
3. 有static是静态代码块，没有static就是非静态代码块
4. 代码部分可以是任何逻辑语句
5. ；号可以写上，也可以省略。

解释：

package com.hspedu.codeblock_;

public class CodeBlock01 {
    public static void main(String[] args) {
        Movie movie = new Movie("你好，李焕英");
    }
}
class Movie{
    private String name="战狼";
    private double price;
    private String director;

    //3个构造器重载
    //1.下面3个构造器都有相同的语句，冗余
    //2.这时就把相同的语句，放在一个代码块中，解决冗余
    //3.这样当我们不管调用那个构造器都会先调用代码块
    //4.代码块的调用优先与构造器
    {
        System.out.println("电影屏幕打开...");
        System.out.println("广告开始...");
        System.out.println("电影正式开始...");
    }
    public Movie(String name) {
        System.out.println(name+"Movie(String name)");
        this.name = name;//这条语句就是把战狼改成了你好，李焕英
        System.out.println(name);//你好，李焕英
        System.out.println(this.name);//你好，李焕英
    }

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

    public Movie(String name, double price, String director) {
        this.name = name;
        this.price = price;
        this.director = director;
    }
}
/*
电影屏幕打开...
广告开始...
电影正式开始...
你好，李焕英Movie(String name)
你好，李焕英
你好，李焕英
 */

代码块使用细节（非常重要）

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

类什么时候加载

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

package com.hspedu.codeblock_;

public class CodeBlockDetail01 {
    public static void main(String[] args) {
        //类什么时候加载
        //1.创建对象实例化(new)
        //AA aa = new AA();//代码块被执行
        //2.创建子类对象实例，父类也会被加载
        //继承的本质，先加载父类，在加载子类
        AA aa1 = new AA();
        /*
        BB 的静态代码块1被执行....
        AA 的静态代码块1被执行....
         */
        //3.使用类的静态成员时（静态属性，静态方法）
        System.out.println(Cat.n1);//先加载Cat类
        /*//没有继承Animal时的输出
        Cat 的静态代码1被执行...
        9999
         */
        //当Cat继承Animal后,先加载父类
        /*
        Animal 的静态代码1被执行...
        Cat 的静态代码1被执行...
        9999
         */


    }
}
class Animal{
    static {
        System.out.println("Animal 的静态代码1被执行...");
    }
}
class Cat extends Animal{
    public static int n1 = 9999;//静态属性
    //静态代码块
    static {
        System.out.println("Cat 的静态代码1被执行...");
    }
}

class BB {//父类

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

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

继承的本质，先加载父类，在加载子类

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

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

调用静态代码块和静态属性初始化（静态代码块和静态属性初始化优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）
调用普通代码块和普通属性的初始化（同上括号）
调用构造方法

package com.hspedu.codeblock_;

public class CodeBlockDetail02 {
    public static void main(String[] args) {
        A a = new A();
    }
}
class A{
    //非静态属性初始化
    private int n2 = getN2();
    //静态属性初始化
    private static int n1 = getN1();
    //普通代码块
    {
        System.out.println("A 普通代码块01");
    }

    //静态代码块
    static {
        System.out.println("A 静态代码块01");
    }
    public static int getN1(){
        System.out.println("getN1被调用....");
        return 100;
    }
    public int getN2(){
        System.out.println("getN2被调用....");
        return 200;
    }
    //无参构造器
    public A(){
        System.out.println("A(),构造器最后被调用");
    }

}
/*
getN1被调用....
A 静态代码块01
getN2被调用....
A 普通代码块01
A(),构造器最后被调用
 */

静态，普通，构造器，（多的话就按顺序排就行了）

构造器里面代码的执行顺序

package com.hspedu.codeblock_;

public class CodeBlockDetail03 {
    public static void main(String[] args) {
        new BBB();//在创建对象时的步骤
        //1.进行类的加载（这个时候就是对静态代码块，静态初始化的）
        //2.创建对象
    }
}
class AAA{

    //无参构造器
    public AAA(){
        //隐藏的命令
        //1.super()
        //2.调用本类的普通代码块
        System.out.println("AAA() 构造器被调用....");
    }
}
class BBB extends AAA{
    {
        System.out.println("BBB的普通代码块...");
    }

    public BBB(){
        //隐藏的命令
        //1.super()//到AAA的构造器
        //2.调用本类的普通代码块(代码块不会被继承)
        System.out.println("BBB() 构造器被调用....");
    }
}
/*
执行的顺序1.BBB无参构造器的隐藏的第一个命令
2.super()到BBB的父类AAA，AAA的无参构造器里也有隐藏的命令，
但AAA的父类是Object没有执行的内容所以执行AAA的类的代码块，
但AAA类也没有代码块，所以执行输出System.out.println("AAA() 构造器被调用....");。
3.轮到BBB类隐藏的第二条命令，调用本类的代码块
System.out.println("BBB的普通代码块...");
4.执行输出System.out.println("BBB() 构造器被调用....");
 */
/*
AAA() 构造器被调用....
BBB的普通代码块...
BBB() 构造器被调用....
 */

super（），调用普通代码块

创建一个子类对象时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：
1. 父类的静态代码块和静态属性（是属性，不是成员。优先级一样，按定义顺序执行）（在类加载的时候执行）
2. 子类的静态代码块和静态属性（优先级一样，按定义顺序执行）（在类加载的时候执行）
3. 父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）（创建对象）
4. 父类的构造方法
5. 子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
6. 子类的构造方法
静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员。

枯寂麻辣

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
代码块，执行顺序，类加载，创建对象

（静态代码块和静态属性初始化优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）普通的代码块，在创建对象实例时，会被隐式的调用。父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）（创建对象）子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）子类的静态代码块和静态属性（优先级一样，按定义顺序执行）（静态代码块只能直接调用静态成员（静态属性和静态方法），（是属性，不是成员。静态，普通，构造器，（多的话就按顺序排就行了）如果是普通代码块，每创建一个对象，就执行。
复制链接

扫一扫