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

深藏阁楼爱情的钟 2024-03-22 14:22 59阅读 0赞

**代码块**  
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();
        }
    }

![在这里插入图片描述][9482ee94fdad4d0d942b1d4587dcb528.png]

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

看下面的代码思考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();
        }
    }

![在这里插入图片描述][15d517e012e54680871eaa40f7cd6d3d.png]  
1、父类静态代码块优先于子类静态代码块执行，且是最早执行  
2、父类实例代码块和父类构造方法紧接着执行  
3、子类的实例代码块和子类构造方法紧接着再执行  
4、第二次实例化子类对象时，父类和子类的静态代码块都将不会再执行

[9482ee94fdad4d0d942b1d4587dcb528.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/02ee1cc2bc4241bdabd4757081b19842.png
[15d517e012e54680871eaa40f7cd6d3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/523286f20eb74cad87898e3d13dea9d7.png