Java代码块(包含创建对象时类的加载)

最新推荐文章于 2023-07-31 19:03:02 发布

逆风路上伴有谁

最新推荐文章于 2023-07-31 19:03:02 发布

阅读量373

点赞数 2

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/qq_63918780/article/details/125365723

版权

Java 专栏收录该内容

24 篇文章 0 订阅

订阅专栏

本文详细解析了Java中的代码块（包括静态代码块和普通代码块）及其在对象创建过程中的执行顺序，强调了如何利用代码块减少代码冗余，并通过案例展示了其在实际编程中的应用。同时，介绍了类加载的时机以及在继承关系中构造方法的调用顺序。

摘要由CSDN通过智能技术生成

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

扩展：

概念：

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

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

基本语法：

修饰符 {

代码

};

注意：

1.修饰符可选，要写的话，也只能写 static

2.代码块分两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块

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

4.;号可以写，也可以不写

案例：

创建一个Student类，有姓名，年龄，成绩三个属性，有三个构造器，要求创建三个对象使用不同的构造器，分别打印相同的三句话。

1.传统方法，不适用代码块

class Student {
    private String name;
    private int age;
    private double score;
    

    public Student(String name) {
        this.name = name;
        System.out.println("这是一个学生");
        System.out.println("正在分享自己所学知识");
        System.out.println("每天进步一点点");
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("这是一个学生");
        System.out.println("正在分享自己所学知识");
        System.out.println("每天进步一点点");
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
        System.out.println("这是一个学生");
        System.out.println("正在分享自己所学知识");
        System.out.println("每天进步一点点");
    }
}

代码冗余。

2.新技术，使用代码块

class Student {
    private String name;
    private int age;
    private double score;

    {
        System.out.println("这是一个学生");
        System.out.println("正在分享自己所学知识");
        System.out.println("每天进步一点点");
    }

    public Student(String name) {
        this.name = name;
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Student(String name, int age, double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
}

细节(复习必看)：

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

2.类加载(一个类只能加载一次)

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

public class CodeDetail01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

class Dog {
    static {
        System.out.println("Dog静态代码块被调用");
    }
}

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

public class CodeDetail01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
    }
}

class Animal {
    static {
        System.out.println("Animal静态代码块被调用");
    }
}


class Dog extends Animal {
    static {
        System.out.println("Dog静态代码块被调用");
    }
}

(3)使用类的静态成员时(静态属性，静态方法)

public class CodeDetail01 {
    public static void main(String[] args) {
        System.out.println(Cat.age);
        Cat.m1();
    }
}

class Cat {
    public static int age = 10;

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

    public static void m1() {
        System.out.println("m1()方法被调用");
    }
}

稍微练习一下

public class CodeDetail01 {
    public static void main(String[] args) {
        System.out.println(Cat.age);
    }
}

class Animal {
    static {
        System.out.println("Animal静态代码块被调用");
    }
}

class Cat extends Animal{
    public static int age = 10;

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

    public static void m1() {
        System.out.println("m1()方法被调用");
    }
}

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

4.创建一个对象时，在一个类调用顺序是：

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

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

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

class A {
    private int n2 = getN2();

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

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

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

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

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

(3)调用构造方法

class A {
    private int n2 = getN2();

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

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

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

    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 构造器被调用...");
    }
}

其他顺序不变，构造器放在最后

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

public A() {
    //super();//父类默认构造器
    //调用普通代码块
    System.out.println("A 构造器被调用...");
}

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

(1)父类的静态代码块和静态属性(优先级一样，按定义顺序执行)

(2)子类的静态代码块和静态属性(优先级一样，按定义顺序执行)

(3)父类普通代码块和普通属性初始化(优先级一样，按定义舒徐执行)

(4)父类构造方法

(5)子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)

(6)子类的构造方法

举个例子：

Father类

class Father {
    private static int m1 = getM1();
    private int m2 = getM2();

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

    {
        System.out.println("Father 普通代码块被调用");
    }

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

    public static int getM1() {
        System.out.println("Father 静态方法被调用");
        return 100;
    }
    public int getM2() {
        System.out.println("Father 普通方法被调用");
        return 200;
    }
}

Son类

class Son extends Father {
    private static int n1 = getN1();
    private int n2 = getN2();

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

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

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

    public static int getN1() {
        System.out.println("Son 静态方法被调用");
        return 100;
    }
    public int getN2() {
        System.out.println("Son 普通方法被调用");
        return 200;
    }
}

测试类

public class CodeDetail03 {
    public static void main(String[] args) {
        new Son();
    }
}

运行结果

扩展：

《编写高质量代码：改善Java程序的151个建议》中第36条建议、第37条建议可以看一下。链接在我的2022.06.20动态。

逆风路上伴有谁

关注

2
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
Java代码块(包含创建对象时类的加载)

Java代码块，创建一个子类时(继承关系)，它的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序
复制链接

扫一扫

专栏目录