Java中初始化顺序

一、无继承情况时的初始化顺序

1、静态代码块和静态成员初始化（按照他们在程序中的先后顺序执行）

2、普通成员变量初始化

3、构造函数

 class A
	 {
	    public A()
	    {
	 	   System.out.println("A的无参构造方法被调用");
	    }
	    public A (String s)
	   {
	 	System.out.println(s);
	   }
	 }
	 public class Test
	  {
	 	 static{
	          System.out.println("静态块1被执行");
	            }
	    static A A1=new A("静态成员A1初始化");
	    A t1=new A("实例变量a1初始化");
	    static A staticA2 =new A("静态成员A2初始化");
	    static{
	          System.out.println("静态块2被执行");
	          }
	    Test()
	    {
	          System.out.println("Test默认构造函数被调用");
	    }
	   A a2=new A("实例变量a2初始化");
	   public static void main(String[] args)
	   {
	 	Test t = new Test();
	   }
	   }

执行结果：
静态块1被执行
静态成员A1初始化
静态成员A2初始化
静态块2被执行

实例变量a1初始化
实例变量a2初始化

Test默认构造函数被调用

二、有继承的情况时的初始化顺序

1 、父类静态成员和静态块

2、子类静态成员和静态块

3、父类初始化（普通成员的初始化-->构造函数的调用）

4、子类初始化（普通成员-->构造函数）

class A
	 {
	   
	    public A (String s)
	   {
	 	System.out.println(s);
	   }
	 }
class B
	  {
	 	
	    A b1=new A("父类实例变量b1初始化");
	    static{
	          System.out.println("父类静态块被执行");
	            }
	    static A B1=new A("父类静态成员b1初始化");
	    public B()
	    {
	 	   System.out.println("父类B的无参构造方法被调用");
	    }

	   }
public class C extends B
{
	 public static void main(String[] args)
	   {
	 	 C c = new C();
	   }
	
   A c1=new A("子类的实例变量c1初始化");
   static{
       System.out.println("子类静态块被执行");
         }
   static A C1=new A("子类静态成员C1初始化");
   public C()
   {
	   System.out.println("子类C的无参构造方法被调用");
   }

  }

执行结果：

父类静态块被执行
父类静态成员b1初始化

子类静态块被执行
子类静态成员C1初始化

父类实例变量b1初始化
父类B的无参构造方法被调用

子类的实例变量c1初始化
子类C的无参构造方法被调用

三、经典面试笔试题

class Singleton 
{     
    
    public static Singleton singleton = new Singleton();    //1 
    public static int a;   
    public static int b = 0;    
    private Singleton() {     
        super();     
        a++;     
        b++;     
    }      
    public static Singleton GetInstence() {     
        return singleton;     
    }     
    
}     
    
public class Test1 {     
      
    public static void main(String[] args) {     
        Singleton mysingleton = Singleton.GetInstence();     
        System.out.println("a="+mysingleton.a);     
        System.out.println("b="+mysingleton.b);     
    }     
    
}    

输出结果：

a=1

b=0

分析：

（1）加载连接时，对Singleton的所有的静态变量分配空间，赋默认的值，所以在这个时候，singleton=null、a=0、b=0。注意b的0是默认值。

 （2）Singleton mysingleton = Singleton.GetInstence(); 调用 Singleton类的静态方法是对 Singleton类的主动使用，初始化 Singleton类。

 （3） Singleton类中的1语句是生成一个 Singleton对象，需要调用其构造方法，调用结束时a=1,b=1。

 （4） public static int a; 没有为a赋初值，a依然为1；

 （5）  public static int b = 0; 为b赋初值 此时b变为0.

一定要分清在加载时是为静态变量赋予默认的初始值，在初始化时才为静态变量赋予真正的表达式的值。

若代码顺序由

public static Singleton singleton = new Singleton();  
    public static int a;  
public static int b = 0;

变为

 

   public static int a;
public static int b = 0;
public static Singleton singleton = new Singleton();

则结果为:

a=1

b=1