面对对象编程（高级）——代码块

基本介绍
代码块又称为初始化块，属于类中的成员[即 是类的一部分]，类似于方法，讲逻辑语句封装在方法体中，通过｛｝包围起来。
但是和方法不同，没有方法名，没有返回，没有参数，只有方法体，而且不用通过对象或类显示调用，而是加载类时，或创建对象时隐式调用。

基本语法

[修饰符] {
代码
}；

注意：
（1）修饰符可选，要写的话，也只能写static
（2）代码块分为两类，使用static修饰的叫静态代码块，没有static修饰的，叫普通代码块/非静态代码块。
（3）逻辑语句可以为任何逻辑语句（输入、输出、方法调用、循环、判断等）。
（4）；分号可以写上，也可以省略。

代码块的好处和案例演示
老师理解：
（1）相当于另外一种形式的构造器（对构造器的补充机制），可以做初始化的操作
（2）场景：如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性
（3）代码块的快速入门

代码块使用注意事项和细节讨论
（1）static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块，每创建一个对象（new对象时，和类加载没关系），就执行。

（2）类什么时候被加载【重要】
a。创建对象实例时（new）
b。创建子类对象实例，父类也会被加载（父类先加载，子类后加载）
c。使用类的静态成员时（静态属性、静态方法）

（3）普通代码块，在创建对象实例时，会被隐式的调用。被创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行。

小结
1.static代码块是类加载时，执行，只会执行一次。
2.普通代码块是在创建对象时调用的，创建一次，调用一次。
3.类加载的3种情况，需要记住。

（4）创建一个对象时，在一个类中，调用顺序是：（重点，难点）
a。调用静态代码块和静态属性初始化（注意：静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用）
b。调用普通代码块和普通属性初始化（注意：普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义的顺序调用）
c。调用构造方法。

class A {
	{
		System.out.println("A的普通代码块01");
	}
	private int n2 = getN2();

	static {
		System.out.println("A的静态代码块01");
	}
	private static int n1 = getN1();
	public static int getN1() {
		System.out.println("getN1被调用...");
		return 100;
	}
	public int getN2() {
		System.out.println("getN2被调用...");
		return 200;
	}
	public A() {
		System.out.println("A()构造器被调用");
	}
}
//main方法
	A a = new A();   //(1)A的静态代码块01  （2）getN1被调用...  （3）A的普通代码块01
					//(4)getN2被调用...  （5）A（）构造器被调用

（5）构造器 的最前面其实隐含了super() 和调用普通代码块，新写一个类演示，静态相关的代码块，属性初始化，在类加载时，就执行完毕，因此是优先于 构造器和普通代码块执行的。

class A {
	public A() { //构造器
		//这里有隐藏的执行要求
		//（1）super(); //继承
		//（2）调用普通代码块的
		System.out.println("ok");
	}
}

class AAA {
	{
		System.out.println("AAA的普通代码块");
	}
	public AAA() {
		//(1)super()
		//(2)调用本类的普通代码块
		System.out.println("AAA()构造器被调用...");
	}
}

class BBB extends AAA {
	{
		System.out.println("BBB的普通代码块...");
	}
	public BBB() {
		//(1)super()
		//(2)调用本类的普通代码块
		System.out.println("BBB()构造器被调用...");
	}
}
//main方法
	new BBB();
	//（1）AAA的普通代码块 （2）AAA()构造器被调用 
	//（3）BBB的普通代码块 （4）BBB()构造器被调用

（6）我们看一下创建一个子类时（继承关系），他们的静态代码块，静态属性初始化，普通代码块，普通属性初始化，构造方法的调用顺序如下：
a。父类的静态代码块和静态属性（优先级一样，按定义顺序执行）
b。子类的静态代码块和静态属性（优先级一样，按定义顺序执行）
c。父类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
d。父类的构造方法
e。子类的普通代码块和普通属性初始化（优先级一样，按定义顺序执行）
f。子类的构造方法

class A02 {
	private static int n1 = getVal01();
	static {
		System.out.println("A02的一个静态代码块..");
	} 
	{
		System.out.println("A02的一个普通代码块..");
	}
	public int n3 = getVal02();
	public static int getVal01() {
		System.out.println("getVal01");
		return 10;
	}
	public int getVal02() {
		System.out.println("getVal02");
		return 10;
	}
	public A02() {
		System.out.println("A02的构造器");
	}
}

class B02 extends A02 {
	private static int n3 = getVal03();
	static {
		System.out.println("B02的一个静态代码块..");
	}
	public int n5 = getVal04();
	{
		System.out.println("B02的一个普通代码块..");
	}
	public static int getVal03() {
		System.out.println("getVal03");
		return 10;
	}
	public int getVal04() {
		System.out.println("getVal04");
		return 10;
	}
	public B02() {
		System.out.println("B02的构造器");
	}
}

//main方法
	new B02();//1.进行类的加载  2.先加载父类A02再加载B02  
			  //3.创建对象  4.从子类的构造器开始

//1.getVal01  2.A02的一个静态代码块..  3.getVal03  4.B02的一个静态代码块..
//5.A02的一个普通代码块..  6.getVal02  7.A02的构造器  8.getVal04
//9.B02的一个普通代码块  10.B02的构造器

（7）静态代码块只能直接调用静态成员（静态属性和静态方法），普通代码块可以调用任意成员。

例题

class Sample {
	Sample(String s)
	{
		System.out.println(s);
	}
	Sample() {
		System.out.println("Sample默认构造函数被调用");
	}
}

class Test {
	Sample sam1 = new Sample("sam1成员初始化");
	static Sample sam = new Sample("静态成员sam初始化");
	static{
		System.out.println("static块执行");
		if (sam == null) System.out.println("sam is null");
	}
	Test() {
		System.out.println("Test默认构造函数被调用");
	}
}
//主方法
public static void main(String str[]) {
	Test a = new Test();
}

//运行结果
//1.静态成员sam初始化	2.static块执行
//3.sam1成员初始化		4.Test默认构造函数被调用