/*代码块：
 *　　　　　  用{}修饰的代码
 *         1.局部代码块：控制变量，存在方法中，控制变量的生命周期（作用域）
 *         2.构造代码块：提取构造方法中的共性，每次创建对象，都会执行，并且在构造方法执行之前执行。
 *         3.静态代码块：随着类的加载而加载，和对象无关，只加载一次。
 */

 1.局部代码块

public class codeblock {
    public static void main(String[] args) {
        {
            int num=10;
        }
        System.out.println(num);
    }
}
当前的变量num局部代码块当中所以输出不了num，所以局部代码块控制变量，存在方法中，控制变量的生命周期（作用域）

2.构造代码块

public class codeblock {
    public static void main(String[] args) {
        student student=new student();
        student student2=new student("bai-boy",18);
    }
}

class student{
    String name;
    int age;
    /*构造方法*/
    public student() {
            System.out.println("bai-boy");
　　　　　　 System.out.println("18");

}

public student(String name,int age) { 
　　　　this.name=name; 
　　　　this.age=age; 
　　　　System.out.println("bai-boy");
　　　　System.out.println("18");
}}

这段代码，这里的构造方法中存在一些共性（共同特点），所以我们可以构造代码块去给他装起来。

public class codeblock {
    public static void main(String[] args) {
        student student=new student();
        student student2=new student("bai-boy",18);
    }
}

class student{
    String name;
    int age;
    {
       System.out.println("bai-boy");
    }
    /*构造方法*/
    public student() {
　　　　　　System.out.println("无参空构造");
    }
    public student(String name,int age) {
        this.name=name;
        this.age=age;
　　　　System.out.println("有参构造");
    }
}
输出的结果为:
bai-boy
无参空构造
bai-boy
有参构造
所以我们的构造代码块是在方法执行之前执行。

3.静态构造
class student{
    String name;
    int age;
    static {
        System.out.println("bai-boy");
    }
    public student() {
        System.out.println("无参空构造");
    }
    public student(String name,int age) {
        this.name=name;
        this.age=age;
        System.out.println("有参构造");
    }
}
静态构造的与构造代码块的区别是前面有个static（静态），静态随着类的加载而加载，而且只加载一次，与对象创建的次数无关，所以是在类的创建后就打印输出结果为·
bai-boy
无参空构造
有参构造

package Object_Oriented;
/*代码块面试题：填写一下输出的顺序*/
public class code_block_test {
    static {
        System.out.println("我是code_block_test的静态代码块");//（1）类的加载而加载，所以首先它打印输出
    }
    {
        System.out.println("我是code_block_test的构造代码块");
    }
    public static void main(String[] args) {//因为code_block_test类没有方法，所以执行main中的代码
        codeclass codeclassone=new codeclass();
        /*首先创建codeclassone对象，因为codeclass类中有static代码块 所以只调用一次，并且在第一次创建中打印输出static代码块代码
          然后打印输出构造代码块，因为是共性所以是在构造方法之前打印输出，所以接下来打印输出构造代码块中的代码*/
        codeclass codeclasstwo=new codeclass("bai-boy",18);
    }
}
class codeclass{
    String name;
    int age;
    static {
        System.out.println("我是codeclass的静态代码块");
    }
    {
        System.out.println("我是codeclass的构造代码块");
    }
    public codeclass() {
        System.out.println("我是codeclass的无参空构造");
    }
    public codeclass(String name,int age) {
        System.out.println("我是codeclass的有参构造");
    }
}
/*
     所以整个输出结果为：
        我是code_block_test的静态代码块
        我是codeclass的静态代码块
        我是codeclass的构造代码块
        我是codeclass的无参空构造
        我是codeclass的构造代码块
        我是codeclass的有参构造
*/