面向对象(10)：代码块（面试涉及到一部分）

面向对象(10)：代码块（面试涉及到一部分）

目的：今后面试的时候，会有相关程序题，需要熟悉不同的代码块的执行顺序

1、代码块：在Java中，使用{}括起来的代码被称为代码块
2、根据其位置和声明的不同，可以分为：
                            （1）局部代码块
                            （2）构造代码块
                            （3）静态代码块
                            （4）同步代码块(后面多线程详细讲解)

局部代码块

局部代码块：
	当作正常的代码看待，格式：只在方法中出现，使用大括号括起来的代码叫局部代码块
好处：
	使用完毕及早释放，提高内存的使用率
执行顺序：
	在一个方法中，顺序执行自上而下
		
public class CodeDemo {
    public static void main(String[] args) {
    	//局部代码块(位置：在方法内)
        {								
            int a =100;				
            System.out.println(a);//第1步执行
        }

        int b =50;
        System.out.println(b);//第2步执行
    }
}

构造代码块

构造代码块：
		在类中方法外定义，每次调用构造方法的时候，都会先执行一遍构造代码，再执行构造方法
执行顺序：构造代码块→构造方法

class Code{
    //无参构造方法
    Code(){
        System.out.println("这是无参构造方法");//第3步执行
    }

    //构造代码块(位置：在类中方法外)
    {
        int x = 100;
        System.out.println(x);//第2步执行:调用构造方法的时候，都会先执行一遍构造代码
    }

}
//测试类
public class CodeDemo {
    public static void main(String[] args) {
        //创建Code对象
        Code code = new Code();//第1步执行
    }
}
            执行顺序：
                    100
                    这是无参构造方法

                    Process finished with exit code 0 

1、测试类中依次含有：构造方法、构造代码块、(main方法中的)局部代码块

​ 执行顺序：局部代码块→构造代码块→构造方法

2、如果创建对象放在局部代码块前面

​ 那么执行顺序：构造代码块→构造方法→局部代码块

​ 因为JVM先加载main()方法 ，在main()方法中自上而下执行

测试类中依次含有：构造方法、构造代码块、(main方法中的)局部代码块
public class CodeDemo {
    //无参构造方法
    CodeDemo(){
        int d = 400;
        System.out.println(d);//第6步执行
    }
    //构造代码块
    {
        int f = 500;
        System.out.println(f);//第5步执行:调用构造方法的时候，都会先执行一遍构造代码
    }

    //main方法
    public static void main(String[] args) {
        //局部代码块1
        {
            int a = 100;
            System.out.println(a);//第1步执行
        }

        int b =50;
        System.out.println(b);//第2步执行
        //局部代码块2
        {
            int c =200;
            System.out.println(c);//第3步执行
        }

        //创建自身对象.为了打印无参构造方法
        CodeDemo codeDemo = new CodeDemo();//第4步执行
    }
}

                执行结果如下：
                        100
                        50
                        200
                        500
                        400

                        Process finished with exit code 0

静态代码块

静态代码块：
	被static修饰的代码块，定义在类中方法外
    	static代码块一旦被执行过一次后，同一个程序不会重复执行。
        静态的内容是属于类的本身，程序的开始到结束只会加载一次，不会重复加载
        静态代码块是随着类的加载而加载，在定义类中优先执行

定义类中依次含有：无参构造方法、构造代码块、静态代码块

测试类中依次含有：(main方法中的)局部代码块

执行顺序：(在测试类最底端创建定义类对象)

(main方法中的)局部代码块→静态代码块→构造代码块→无参构造方法

//定义类
class Demo {
    //无参构造方法
    Demo() {
        System.out.println("Demo无参构造方法");
    }
    //构造代码块
    {
        int x = 200;
        System.out.println(x);
    }
    //静态代码块
    static {
        int w = 99;
        System.out.println(w);
    }
}
//测试类
public class CodeDemo {
	//main方法
    public static void main(String[] args) {
		//局部代码块1
        {
            int a = 100;
            System.out.println(a);
        }


        int a2 = 11;
        System.out.println(a2);
		//局部代码块2
        {
            int b = 200;
            System.out.println(b);
        }
		//创建定义类对象
        Demo d = new Demo();

定义类中依次含有：无参构造方法、构造代码块、静态代码块

测试类中依次含有：无参构造方法、构造代码块、静态代码块、(main方法中的)局部代码块

执行顺序：(在测试类最底端：创建定义类对象→创建测试类对象)

测试类的静态代码块→(main方法中的)局部代码块→定义类中静态代码块→定义类中构造代码块→定义类中无参构造方法→测试类中构造代码块→测试类中无参构造方法

//定义类
class Demo {
    //无参构造方法
    Demo() {
        System.out.println("Demo无参构造方法");
    }
    //构造代码块
    {
        int x = 200;
        System.out.println(x);
    }
    //静态代码块
    static {
        int w = 99;
        System.out.println(w);
    }
}
//测试类
public class CodeDemo {
	//无参构造方法
    CodeDemo() {
        int y = 400;
        System.out.println(y);
    }
	//构造代码块
    {
        int q = 500;
        System.out.println(q);
    }
    //静态代码块
    static {
        int r = 700;
        System.out.println(r);
    }
	//main方法
    public static void main(String[] args) {
		//局部代码块1
        {
            int a = 100;
            System.out.println(a);
        }


        int a2 = 11;
        System.out.println(a2);
		//局部代码块2
        {
            int b = 200;
            System.out.println(b);
        }
		//创建定义类对象
        Demo d = new Demo();
        //创建测试类对象
        CodeDemo codeDemo = new CodeDemo();
/*        
 执行顺序概述（内存图）：
 首先运行程序，JVM会将class文件和静态成员加载到方法区中，
 静态区中两个class文件的静态成员在里面的位置其实是分开的，
 之后java虚拟机会去测试类的静态区中识别测试类的main方法(),
 而在测试类的静态区里还有静态代码块，所以JVM会 先执行测试类的静态代码块 再把main方法加载到栈里面；
 之后执行main方法中局部代码块；
 然后调用无参构造方法为Demo创建对象d，执行定义类中无参构造方法，但是
之后调用无参构造方法为CodeDemo创建对象codeDemo，执行测试类中构造代码块，然后执行
（为什么没有r？因为静态代码块在被执行过一次之后，再次调用不执行。）
*/