1 非静态代码块
非静态代码块特点
①可以为实例变量(非静态的属性)初始化
②每次创建对象的时候，都会执行一次，且先于构造器执行
③若有多个非静态的代码块，那么按照定义的顺序从上到下依次执行
④代码块中既可以调用非静态的变量和方法，也可以可以调用静态的变量和方法
测试代码：
public class BlockTest {
public static void main(String[] args) {
MyClass my1 = new MyClass();
//MyClass my2 = new MyClass("java");
}
}
class MyClass {
private String str;
{
System.out.println("非静态代码块1");
}
public MyClass() {
System.out.println("无参构造");
}
public MyClass(String str) {
this.str = str;
System.out.println("有参构造");
}
{
System.out.println("非静态代码块2");
}
}
运行结果：
非静态代码块1
非静态代码块2
无参构造
2 实例初始化
实例初始化过程：创建对象时，为对象进行初始化的操作
①为成员变量显式赋值
②执行非静态代码块
③执行构造器
Java编译器会把这三个部分的代码，合成一个叫做 ([形参列表]) 实例初始化方法
即编译后的.class字节码信息中，是没有构造器这个概念。
([形参列表]) 实例初始化方法的代码就是由三个部分组成：
①成员变量显式赋值的代码
②非静态代码块中的代码
③构造器中的代码
其中①和②按定义顺序依次执行，③最后执行。
而且，有几个构造器，就会有几个实例初始化方法。那么当你创建对象的时候，调用对应的构造器时，其实执行的是对应的实例初始化方法 ([形参列表])
代码示例：
public class InitTest {
public static void main(String[] args) {
Demo d1 = new Demo();
//Demo d2 = new Demo("java");
}
}
class Demo{
{
System.out.println("非静态代码块1");
}
private String str = assign();//调用方法，为str进行显式赋值
public Demo(){
System.out.println("无参构造");
}
public Demo(String str){
this.str = str;
System.out.println("有参构造");
}
{
System.out.println("非静态代码块2");
}
public String assign(){
System.out.println("为成员变量赋值");
return "hello";
}
}
3 子类实例初始化
(1)先执行父类的实例初始化方法
它由三部分组成：
成员变量的显式赋值
非静态代码块
构造器
(2)再执行子类的实例初始化方法
它由三部分组成：
成员变量的显式赋值
非静态代码块
构造器
super()或super(实参列表) 表面是调用父类的构造器，其实是调用父类对应的实例初始化方法
super()或super(实例列表) 表面是在子类构造器的首行，其实是在子类实例初始化方法的首行
代码示例：
public class InitTest2 {
public static void main(String[] args) {
Son s = new Son();
}
}
class Father {
private String strFather = assignFather();
{
System.out.println("父类的非静态代码块");
}
public Father(){
System.out.println("父类的无参构造");
}
public String assignFather(){
System.out.println("父类的assignFather()");
return "father";
}
}
class Son extends Father {
private String strSon = assignSon();
{
System.out.println("子类的非静态代码块");
}
public Son(){
//super() ==> 调用父类的实例初始化方法，而且它在子类实例初始化方法的首行
System.out.println("子类的无参构造");
}
public String assignSon(){
System.out.println("子类的assignSon()");
return "son";
}
}
运行结果：
父类的assignFather()
父类的非静态代码块
父类的无参构造
子类的assignSon()
子类的非静态代码块
子类的无参构造
子类为成员变量显式赋值方法重写父类显式赋值方法时，调用的子类重写的方法，代码示例：
public class InitTest3 {
public static void main(String[] args) {
Son s = new Son();
}
}
class Father {
private String strFu = assign();
{
System.out.println("父类的非静态代码块");
}
public Father(){
System.out.println("父类的无参构造");
}
public String assign(){
System.out.println("父类的assign()");
return "father";
}
}
class Son extends Father {
private String strSon = assign();
{
System.out.println("子类的非静态代码块");
}
public Son(){
//super()  ==>调用父类的实例初始化方法，而且它在子类实例初始化方法的首行
System.out.println("子类的无参构造");
}
public String assign(){
System.out.println("子类的assign()");
return "son";
}
}
运行结果：
子类的assign()
父类的非静态代码块
父类的无参构造
子类的assign()
子类的非静态代码块
子类的无参构造

非静态代码块和实例初始化方法
类的成员： （1）属性 （2）方法 （3） 构造器
类的第四成员：代码块
作用：为属性初始化
一、非静态代码块
1、语法格式：

【修饰符】  class 类名 【extends 父类】{

{

非静态的代码块

}

}
2、执行特点

（1）在创建对象的时候自动执行，每创建一个对象就执行一次

如果有多个非静态的代码块，按照顺序执行

（2）先与构造器执行的

（3）非静态代码块与属性的显示赋值他两谁在上面谁先执行

（4）如果创建了子类的对象，会先执行父类的非静态代码块、父类的属性的显试赋值、父类的构造器
3、实例初始化(…)

（1） .java代码编译为   .class时，会把diamante重新组装，如果类中有n个构造器，就会重新组装为n个实例化初始方法。

无参构造 -> ()

有参构造 -> (形参列表)
（2）实例初始化方法由三个部分组成

（A）属性的显式赋值语句

（B）非静态代码块语句

（C）构造器语句

其中（A）（B）是按照顺序组装的，但是（C）无论放在那里，都在最后
（3）创建子类对象的时候会先调用父类的实例化方法
public class TestNonStaticBlock {
	public static void main(String[] args) {
		Son s1 = new Son();

		
		//构造器是最后执行的所以num的值是3
		System.out.println(s1.getNum());//3
		
	}
}

class Father{
	Father(){
		System.out.println("父类的无参构造");
	}
	{
		System.out.println("父类的非静态的代码块1");
	}
	
	{
		System.out.println("父类的非静态的代码块2");
	}
	
	private int i= getNumberI();//为i属性赋值的
	
	public int getNumberI() {
		System.out.println("getNumberI()");
		return 1;
	}

	public int getI() {
		return i;
	}

	
}

class Son extends Father{
	
	Son(){
		System.out.println("无参构造");
		num = 3;
	}
	{
		System.out.println("非静态的代码块1");
		num = 2;
	}
	
	{
		System.out.println("非静态的代码块2");
	}
	
	private int num= getNumber();//为num属性赋值的
	
	public int getNumber() {
		System.out.println("getNum()");
		return 1;
	}

	public int getNum() {
		return num;
	}
	
	
}





下面程序运行时的内存顺序


非静态代码块和构造器和显式赋值之间的执行顺序（题目很重要，有时间得看一下）
练习一
public class TestInit1 {
	public static void main(String[] args) {
		A obj = new A(20);
	}
}
class A{
	private int a = getInt();
	
	{
		a++;
		System.out.println("(1)A非静态代码块");
		System.out.println("(1)a = " + a);
	}
	
	A(int num){
		a = num;
		System.out.println("(2)A有参构造");
		System.out.println("(2)a = " + a);
	}
	
	private int getInt(){
		System.out.println("(3)A->getInt");
		System.out.println("(3)a = " + a);
		return 1;
	}
}

/*
(3)A->getInt
(3)a = 0
(1)A非静态代码块
(1)a = 2
(2)A有参构造
(2)a = 20
 */



练习二
/*
实例初始化的过程：
	（1）实例初始化：调用/执行 实例初始化的方法<init>(...)
	（2）实例初始化方法的方法体由三个部分组成
	第一 属性显示赋值
	第二 非静态代码块
	第三 构造器
	（3）创建子类对象的时候会先执行父类的实例初始化方法
 */

public class TestInit2 {
	public static void main(String[] args) {
		A obj = new B(20);
	}
}
class A{
	private int a = getInt();
	
	{
		a++;
		System.out.println("(1)非静态代码块");
		System.out.println("(1)a = " + a);
	}
	
	A(int num){
		a = num;
		System.out.println("(2)A:有参构造");
		System.out.println("(2)a = " + a);
	}
	
	public int getInt(){
		System.out.println("(3)A->getInt");
		System.out.println("(3)a = " + a);
		return 1;
	}
}
class B extends A{
	private int b = getIntValue();
	
	{
		b++;
		System.out.println("(1)B:非静态代码块");
		System.out.println("(1)b = " + b);
	}
	
	B(int num){
		super(num);
		b = num;
		System.out.println("(2)B:有参构造");
		System.out.println("(2)b = " + b);
	}
	
	public int getIntValue(){
		System.out.println("(3)B->getIntValue");
		System.out.println("(3)b = " + b);
		return 1;
	}
}

/*
(3)A->getInt
(3)a = 0
(1)非静态代码块
(1)a = 2
(2)A:有参构造
(2)a = 20
(3)B->getIntValue
(3)b = 0
(1)B:非静态代码块
(1)b = 2
(2)B:有参构造
(2)b = 20
 */


练习三
（里面有关于多态重写的问题，比较复杂好好看看）

如果看了不是很懂的话再去看看练习四的注释
/*
实例初始化的过程：
	（1）实例初始化：调用/执行 实例初始化的方法<init>(...)
	（2）实例初始化方法的方法体由三个部分组成
	第一 属性显示赋值
	第二 非静态代码块
	第三 构造器
	（3）创建子类对象的时候会先执行父类的实例初始化方法
	
	（4） 注意：通常面试题当中注意方法重写的问题
	
父类A的实例初始化的方法<init>(...)
❤❤（1）a = getInt();  --> 等价于a = this.getInt()  这个this表示当前的对象，表示正在创建的对象，现在正在创建的是子类的对象，那么通过子类的对象调用getInt（）是执行子类的重写的getInt（）
（2）{
		a++;
		System.out.println("(1)非静态代码块");
		System.out.println("(1)a = " + a);
	}
（3）构造器
        a = num;
		System.out.println("(2)A:有参构造");
		System.out.println("(2)a = " + a);

子类B的实例初始化的方法<init>(...)
（1）b = getInt();
（2）{
		b++;
		System.out.println("(1)B:非静态代码块");
		System.out.println("(1)b = " + b);
	}
（3）构造器
		super(num);
		b = num;
		System.out.println("(2)B:有参构造");
		System.out.println("(2)b = " + b);
 */
public class TestInit3 {
	public static void main(String[] args) {
		A obj = new B(20);
	}
}
class A{
	private int a = getInt();//这个地方有一个陷阱，注意是重写
	
	{
		a++;
		System.out.println("(1)非静态代码块");
		System.out.println("(1)a = " + a);
	}
	
	A(int num){
		a = num;
		System.out.println("(2)A:有参构造");
		System.out.println("(2)a = " + a);
	}
	
	public int getInt(){
		System.out.println("(3)A->getInt");
		System.out.println("(3)a = " + a);
		return 1;
	}
}
class B extends A{
	private int b = getInt();
	
	{
		b++;
		System.out.println("(1)B:非静态代码块");
		System.out.println("(1)b = " + b);
	}
	
	B(int num){
		super(num);
		b = num;
		System.out.println("(2)B:有参构造");
		System.out.println("(2)b = " + b);
	}
	
	public int getInt(){
		System.out.println("(3)B->getInt");
		System.out.println("(3)b = " + b);
		return 1;
	}	
}

/*
 (3)A->getInt
 (3)a = 0
 (1)非静态代码块
 (1)a = 2
 (2)A:有参构造
 (2)a = 20
 */



练习四
/*
 *Override或者Overwrite  重写  覆盖
 *this在类中，就看的是A类中的getInt()，就近原则，因为这个getInt没有被覆盖掉
 *如果getInt()被重写，被覆盖，即使在A类中，通过子类的对象this，看到的只有子类重写后的getInt()方法 
 * 
 */

public class TestInit4 {
	public static void main(String[] args) {
		A obj = new B(20);
	}
}
class A{
	private int a = getInt();//因为getInt() 方法是private，在子类中不可见不会被重写
	//虽然这个地方也是this.getInt()，但是子类中是私有的，所以根据就近原则调用的父类的getInt()
	{
		a++;
		System.out.println("(1)非静态代码块");
		System.out.println("(1)a = " + a);
	}
	
	A(int num){
		a = num;
		System.out.println("(2)A:有参构造");
		System.out.println("(2)a = " + a);
	}
	
	private int getInt(){
		System.out.println("(3)A->getInt");
		System.out.println("(3)a = " + a);
		return 1;
	}
}
class B extends A{
	private int b = getInt();
	
	{
		b++;
		System.out.println("(1)B:非静态代码块");
		System.out.println("(1)b = " + b);
	}
	
	B(int num){
		super(num);
		b = num;
		System.out.println("(2)B:有参构造");
		System.out.println("(2)b = " + b);
	}
	
	private int getInt(){
		System.out.println("(3)B->getInt");
		System.out.println("(3)b = " + b);
		return 1;
	}	
}

关于静态代码块
静态代码块的写法：
static{
System.out.println("我是静态代码块");
}
静态代码块的特点：
1.执行优先级高于非静态的初始化块，它会在类初始化的时候执行一次，执行完成便销毁，它仅能初始化类变量，即static修饰的数据成员。
2.随着类的加载而执行，而且只执行一次
先说一下类加载，一个程序要想运行，首先要把代码加载到内存中，然后才能去和CPU交流，这是冯诺依曼计算机规定的。Java也是一样，Java的.class字节码文件要想执行，首先也要加载到内存，由类加载器把字节码文件的代码加载到内存中，这一步就叫类加载，这是首先要进行的。
关于非静态代码块：
非静态代码块的写法：
{
System.out.println("我是非静态代码块");
}
非静态代码块的特点：
1.执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，在每个对象生成时都会被执行一次，它可以初始化类的实例变量。非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。
2.非静态代码块在每new一次就执行一次
静态代码块与非静态代码库的异同点：
相同点：
都是在JVM加载类时且在构造方法执行之前执行，在类中都可以定义多个，一般在代码块中对一些static变量进行赋值。
不同点：
1.静态代码块在非静态代码块之前执行(静态代码块--》非静态代码块--》构造方法)。
静态代码块只在第一次new执行一次，之后不在执行，而非静态代码块在每new一次就执行一次。非静态代码块可以     在普通方法中定义(个人感觉作用不大);而静态代码块不行。
2.静态代码块是自动执行的；
静态方法是被调用的时候才执行的；
作用：
静态代码块可以用来初始化一些项目最常用的变量和对象；静态方法可以用作不创建对象也可以能需要执行的代码。
关于构造函数：
构造函数写法：
public class Father{
Father(){　　　　System.out.println("我是构造函数");
}
}
构造函数的特点：
1.构造函数的名字必须和类名完全相同，构造函数不能有
2.返回值，不写void，构造函数不可以被子类继承
3.构造函数可以重载但是不可以被子类覆盖。
关于静态代码块,非静态代码块及构造函数的执行顺序
1.只在父类Class中测试
public classFather {static{
System.out.println("父类的静态代码块");
}
{
System.out.println("父类的非静态代码块");
}
Father() {
System.out.println("父类的构造函数");
}public static voidmain(String[] args) {
System.out.println("new父类前的main方法");newFather();
System.out.println("new父类后的main方法");
}
}
总结:
只在父类Class中的执行顺序:
静态代码块>new 对象前的main方法顺序执行>非静态代码块>构造函数>new 对象后的main方法顺序执行
2.在继承了父类的子类Class中测试
public class Son extendsFather {static{
System.out.println("子类的静态代码块");
}
{
System.out.println("子类的非静态代码块");
}
Son() {
System.out.println("子类的构造函数");
}public static voidmain(String[] args) {
System.out.println("new子类前的main方法");newSon();
System.out.println("new子类后的main方法");
}
}
总结:
在继承了父类的子类Class中的执行顺序:
父类的静态代码块>子类的静态代码块>new 对象前的main方法顺序执行>父类的非静态代码块>父类的构造函数>子类的非静态代码块>子类的构造函数>new 对象后的main方法顺序执行
3.在父类的Class中测试继承了父类的子类Class
public classFather {static{
System.out.println("父类的静态代码块");
}
{
System.out.println("父类的非静态代码块");
}
Father() {
System.out.println("父类的构造函数");
}public static voidmain(String[] args) {
System.out.println("new子类前的main方法");newSon();
System.out.println("new子类后的main方法");
}
}
总结:
在父类的Class中测试继承了父类的子类Class中的执行顺序:
父类的静态代码块>new 对象前的main方法顺序执行>子类的静态代码块>父类的非静态代码块>父类的构造函数>子类的非静态代码块>子类的构造函数>new 对象后的main方法顺序执行
第3个(在父类的Class中测试继承了父类的子类Class)和第2个(在继承了父类的子类Class中测试)对比:
左图是在父类中new 子类然后执行main方法，右图是子类中new 子类然后执行main方法
可以看出来,父类new 子类之前,先执行父类的静态代码块,然后main函数里面的代码顺序执行,直到new 了子类,然后执行子类的静态代码块,然后父类非静态代码块>父类构造函数>子类非静态代码块>子类构造函数>new子类后的main方法顺序执行 在父类中执行了main方法，本身父类执行main方法就会执行一次静态代码块，但是在父类中main方法new了一次子类，按继承关系，父类中的静态代码块应该还会执行，但是控制台中却没有打印，这就是因为静态代码块的特征的原因所致，随着类的加载而执行，而且只执行一次.
如果还是有疑问,则看一下代码:

Java中静态代码块、代码块和构造函数执行顺序
概念
静态代码块
代码块
执行顺序
与继承共用时的执行顺序
父类
子类
运行
结果

概念
静态代码块
特点:

随着类的加载而执行，而且只执行一次。
执行优先级高于非静态的初始化块，它会在类初始化的时候执行一次，执行完成便销毁，它仅能初始化类变量，即static修饰的数据成员。
代码块
特点:

随着类的加载而执行，而且只执行一次。
执行的时候如果有静态初始化块，先执行静态初始化块再执行非静态初始化块，在每个对象生成时都会被执行一次，它可以初始化类的实例变量。非静态初始化块会在构造函数执行时，在构造函数主体代码执行之前被运行。
执行顺序
静态代码块----->非静态代码块-------->构造函数
与继承共用时的执行顺序
父类
class  Father{
    public Father(){
        System.out.println("父类构造方法");
    }
    {
        System.out.println("父类代码块");
    }
    static {
        System.out.println("父类静态代码块");
    }
    public static void method1(){
        System.out.println("静态方法");
    }
}

子类
class  Child extends Father{
	public Child(){
		System.out.println("子类构造方法");
	}
	{
		System.out.println("子类代码块");
	}
	static {
		System.out.println("子类静态代码块");
	}
}

运行
class  TestClass{
	public static void main(String[] args) {
        new Child();
    }
}

结果
父类静态代码块
子类静态代码块
父类代码块
父类构造方法
子类代码块
子类构造方法

可以看出到实际上执行顺序应该是:
父类静态代码块 ——> 子类静态代码块 ——> 父类代码块 ——> 父类构造方法 ——> 子类代码块 ——> 子类构造方法