代码块介绍

代码块知识点

代码块：

在java中使用{}括起来的代码被称为代码块，根据其位置和声明的不同，可以分为局部代码块，构造代码块，静态代码块，同步代码块（多线程学习）

局部代码块：

在方法中出现，限定变量的生命周期，及早释放，提高内存的利用

public class CodeDemo {
    public static void main(String[] args) {
        /**
         * 局部代码块
         */
        {
            int x = 10;
            System.out.println(x);
        }
//        System.out.println(x);  报错，访问不到x
    }
}

在同一个类中的同一个方法中，如果存在多个局部代码块，执行顺序是自上而下的

public class CodeDemo {
    public static void main(String[] args) {
        /**
         * 局部代码块
         */
        {
            int x = 10;
            System.out.println(x);
        }
//        System.out.println(x);  报错，访问不到x
        {
            int y = 20;
            System.out.println(y);
        }

        {
            int z = 30;
            System.out.println(z);
        }
    }
}

构造代码块：（在创建对象的时候调用）

定义在类中方法外，每次调用都执行

public class CodeDemo {
    /**
     *构造代码块：定义在类中方法外，使用{}括起来的代码
     */
    {
        int x = 200;
        System.out.println(x);
    }

    public static void main(String[] args) {
        /**
         * 局部代码块
         */
        {
            int x = 10;
            System.out.println(x);
        }

//        System.out.println(x);  报错，访问不到x
        {
            int y = 20;
            System.out.println(y);
        }

        {
            int z = 30;
            System.out.println(z);
        }
        CodeDemo codeDemo = new CodeDemo();
    }
}

当一个类中即存在构造代码块，又存在构造方法的时候，在创建对象的时候，会先执行构造代码块，再执行构造方法

构造代码块 --> 构造方法

public class CodeDemo {
    /**
     * 构造方法
     */
    CodeDemo(){
        int y = 300;
        System.out.println(y);
    }

    /**
     *构造代码块：定义在类中方法外，使用{}括起来的代码
     */
    {
        int x = 200;
        System.out.println(x);
    }

    public static void main(String[] args) {
        /**
         * 局部代码块
         */
        {
            int x = 10;
            System.out.println(x);
        }

//        System.out.println(x);  报错，访问不到x
        {
            int y = 20;
            System.out.println(y);
        }

        {
            int z = 30;
            System.out.println(z);
        }
        CodeDemo codeDemo = new CodeDemo();
    }
}

无论类中有多少个构造代码块，它们之间会先进行自上而下的顺序执行，再执行构造方法

public class CodeDemo {   
    /**
     * 构造方法
     */
    CodeDemo(){
        int y = 300;
        System.out.println(y);
    }

    /**
     *构造代码块：定义在类中方法外，使用{}括起来的代码
     */
    {
        int x = 200;
        System.out.println(x);
    }

    {
        int x = 400;
        System.out.println(x);
    }

    {
        int x = 500;
        System.out.println(x);
    }

    public static void main(String[] args) {
        /**
         * 局部代码块
         */
        {
            int x = 10;
            System.out.println(x);
        }
//        System.out.println(x);  报错，访问不到x
        {
            int y = 20;
            System.out.println(y);
        }

        {
            int z = 30;
            System.out.println(z);
        }

        CodeDemo codeDemo = new CodeDemo();

        {
            int z = 40;
            System.out.println(z);
        }
    }
}

 

静态代码块：

在类中方法外出现，加了static修饰

不创建对象的时候，依然有输出11，静态代码块是优先于其他代码块之前执行的

静态代码块 --> 局部代码块 --> 构造代码块 --> 构造方法

public class CodeDemo {   
    /**
     * 构造方法
     */
    CodeDemo(){
        int y = 300;
        System.out.println(y);
    }

    /**
     *构造代码块：定义在类中方法外，使用{}括起来的代码
     */
    {
        int x = 200;
        System.out.println(x);
    }

    
    /**
     *静态代码块
     */
    static{
        int a = 11;
        System.out.println(a);
    }

    public static void main(String[] args) {
       
    }
}

静态代码块和局部代码块同时存在的时候，先执行静态代码块，再执行局部代码块

输出11，10，20，30

public class CodeDemo {
    /**
     *静态代码块
     */
    static{
        int a = 11;
        System.out.println(a);
    }

    public static void main(String[] args) {
        /**
         * 局部代码块
         */
        {
            int x = 10;
            System.out.println(x);
        }
//        System.out.println(x);  报错，访问不到x
        {
            int y = 20;
            System.out.println(y);
        }

        {
            int z = 30;
            System.out.println(z);
        }
    }
}

无论类中有多少个静态代码块，它们之间会先进行自上而下的顺序执行

静态代码块在加载的时候执行，并且只执行一次

public class CodeDemo {
    /**
     * 静态代码块
     */
    static{
        int a = 22;
        System.out.println(a);
    }

    /**
     * 构造方法
     */
    CodeDemo(){
        int y = 300;
        System.out.println(y);
    }

    /**
     *构造代码块：定义在类中方法外，使用{}括起来的代码
     */
    {
        int x = 200;
        System.out.println(x);
    }

    {
        int x = 400;
        System.out.println(x);
    }

    {
        int x = 500;
        System.out.println(x);
    }

    /**
     *静态代码块
     */
    static{
        int a = 11;
        System.out.println(a);
    }

    public static void main(String[] args) {
        /**
         * 局部代码块
         */
        {
            int x = 10;
            System.out.println(x);
        }
//        System.out.println(x);  报错，访问不到x
        {
            int y = 20;
            System.out.println(y);
        }

        {
            int z = 30;
            System.out.println(z);
        }

        CodeDemo codeDemo = new CodeDemo();
        CodeDemo codeDemo1 = new CodeDemo();

        {
            int z = 40;
            System.out.println(z);
        }
    }
}

 

代码块练习

class Student2{
    static{
        System.out.println("这是在Student2类中的静态代码块");  //1
    }
    {
        System.out.println("这是在Student2类中的构造代码块");  //2
    }
    Student2(){
        System.out.println("这是在Student2类中的无参构造方法");  //3
    }
}

public class CodeTest {
    static{
        System.out.println("这是在CodeTest类中的静态代码块");  //4
    }

    public static void main(String[] args) {
        System.out.println("开始执行main方法");  //5
        {
            System.out.println("这是在CodeTest类中的局部代码块");  //6
        }
        Student2 student2 = new Student2();

    }
}

执行顺序是456123

为什么先执行4而不是先执行1？

因为我们先执行main方法，而main方法在CodeTest类中。先加载CodeTest类，当new对象的时候才会加载Student2类