java类与类的继承中，单例情况下，类的静态代码块，代码块，构造方法 执行情况总结

单一类情况

父类A的代码情况：

    public class A {

	public static String a1="测试数据A";
	
	static {
		System.out.println("这是A的静态代码块");
	}
	
	{
		System.out.println("这是A的普通代码块");
	}
	
	public  static void fun1() {
		System.out.println("这是一个A的静态函数");
	}
}

在test类里进行测试

System.out.println(A.a1);

结果为：

这是A的静态代码块
测试数据A

类B继承A后情况

类B代码：

public  class B extends A{

	public static String a1="测试数据B";
	public B() {
		System.out.println("这是构造方法!");
	}

	{
		System.out.println("这是普通代码块");
	}
	
	static {
		System.out.println("这是静态代码块");
	}

	public  static void fun2() {
		System.out.println("这是一个静态函数");
	}
	
}

测试方法1：

	    B.fun1();//直接调用A的静态方法

结果为：

这是A的静态代码块
这是一个A的静态函数

测试方法2：

  B.fun2();//直接调用B的静态方法 

结果为：

这是A的静态代码块
这是B的静态代码块
这是一个B的静态函数

测试方法3：

new B();//new 一个B

结果为：

这是A的静态代码块
这是B的静态代码块
这是A的普通代码块
这是B的普通代码块
这是B的构造方法!

单例模式状态下

1.不懒的时候

public class B {

	private static B b = new B();
	public static String a1 = "测试数据B";
	private B() {
		System.out.println("这是B的构造方法!");
	}
	{
		System.out.println("这是B的普通代码块");
	}
	static {
		System.out.println("这是B的静态代码块");
	}
	public static B getInstance() {
		System.out.println("这是一个B的静态函数");
		return b;
	}
}

结果为：

这是B的普通代码块
这是B的构造方法!
这是B的静态代码块
这是一个B的静态函数

2.懒汉式

    public class B {
	private static B b = null;
	public static String a1 = "测试数据B";
	public B(int a) {
	}
	private B() {
		System.out.println("这是B的构造方法!");
	}
	{
		System.out.println("这是B的普通代码块");
	}
	static {
		System.out.println("这是B的静态代码块");
	}
	public static B getInstance() {
		System.out.println("这是一个B的静态函数");
		if(b==null)
			b= new B();
		return b;
	}
}

结果为：

B b =B.getInstance();//测试代码
B b1=new B(1);//测试代码

这是B的静态代码块
这是一个B的静态函数
这是B的普通代码块
这是B的构造方法!

这是B的普通代码块

总结：

1.所有有继承关系的类从顶层开始先执行 静态代码块 然后执行到底层类，然后是 普通代码块，最后才是构造方法。

2.静态代码块只允许一次，普通代码块可以运行多次

3.静态代码块只要是关于此类的一切方法、构造函数、静态常量、静态方法等，就会运行

4.普通代码块是构造函数时才会运行

5.以上是说明不符合不懒的单例模式

6.不懒的单例模式会先创建实例，然后创建实例时，实例的创建优先于静态代码块，而静态代码块是第一次运行，此时创建实例相当于第二次调用此类，故此时静态代码块在构造函数后运行。

7.如果有问题希望您可以指出，感激不尽！