java非静态代码块和静态代码块介绍

news2024/9/23 1:19:47

代码块
SE.10.0…02.28

非静态普通代码块：定义在方法内部的代码块，不用任何关键字修饰，又名构造代码块、实例代码块
静态代码块：用static修饰的代码块

非静态代码块

public class Test {
    public static void main(String[] args) {
        {
            //普通代码块
            int a = 10;
            System.out.println(a);//打印10
        }
        int a = 100;
        System.out.println(a);//打印0100
    }
}

构造代码块（实例代码块，非静态代码块）

class Student {
    private static String classroom = "八年级二班";//班级
    private String name;//姓名
    private int age;//年龄

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    {
        System.out.println("构造代码块/非静态代码块/实例代码块，一般用于初始化非静态的对象属性");
        System.out.println("而且在顺序上他会比构造方法先被编译器调用");
        name = "baixian";//所以这里对象实例化后的name应该是白线，因为构造方法最后运行
    }
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student("白线",18);
        
    }
}

但是如果我的构造方法是空的，或者我没有写构造方法，那么实例化就赋值的就是我构造代码块里面的值

class Student {
    private static String classroom = "八年级二班";//班级
    private String name;//姓名
    private int age;//年龄

    public Student() {
    }

    {
        System.out.println("构造代码块/非静态代码块哦/实例代码块吗，一般用于初始化非静态的对象属性");
        System.out.println("如果构造代码为空，那么实例化的值就会优先选择这");
        name = "baixian";//所以这里对象实例化后的name应该是baixian
    }

    public String getName() {
        return name;
    }
    
}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getName());
    }
}

那么如果定义类的成员变量的时候初始就附了值，构造代码块里也赋了值，那么究竟实例化成哪一个的

class Student {
    
    private String classroom = "八年级二班";//班级
    private String name = "白线";//姓名
    private int age;//年龄

    {
        System.out.println("无论是一开始赋值，还是构造代码块赋值，本身都是非静态的，所以谁最后执行，谁就是实例化都的值");
        this.name = "baixian";//所以这里对象实例化后的name应该是白线
    }
    public Student() {
    }

    public String getName() {
        return name;
    }

}

public class Test {
    public static void main(String[] args) {
        Student student = new Student();
        System.out.println(student.getName());
    }
}

实际底层是编译器将构造代码块（非静态代码块）全部拷贝到构造方法里面，并且放在最前面。这样就能更深刻理解是这样的一个执行顺序了。

静态代码块

只要类被加载，就会先执行静态代码块，并且无论实例化几次，静态代码块只会被执行一次

class Student {
    static {
        System.out.println("执行静态代码块");
    }
    private String classroom = "八年级二班";//班级
    private String name = "白线";//姓名
    private int age;//年龄

    {
        System.out.println("执行非静态代码块");
    }

    public Student() {
    }


}

public class Test {
    public static void main(String[] args) {
        Student student1 = new Student();
        Student student2 = new Student();
    }
}

在这里插入图片描述

在继承背景下的静态代码块与非静态代码块，构造方法的执行顺序

看下面的代码思考123456这六行代码的执行顺序

class Animal {
    static {
        System.out.println("Animal static{}");//1
    }

    public String name;
    public int age;

    {
        System.out.println("Animal{}");//2
    }

    public Animal() {
        System.out.println("Animal()");//3
    }
}


class Dog extends Animal {
    static {
        System.out.println("Dog static{}");//4
    }

    {
        System.out.println("Dod{}");//4

    }

    public Dog() {
        System.out.println("Dog()");//6
    }

    public void wangwang() {
        System.out.println(name + "汪汪叫");//5
    }
}

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