new 对象，初始化对象时的代码执行顺序（构造器，属性，代码块）

new 对象时的执行顺序：

1，静态资源（包括静态属性，静态方法，静态代码块）：父类静态执行完所有静态资源再执行子类静态；执行一个类时，按所有静态资源的上下顺序来；（第一次new对象时就会检查这个类是否加载了，如果没有，就进行类加载，类加载的同时，静态资源也会同时加载；如果在new对象的时候类已经加载了，那么就不会再加载静态资源了，因为static只执行一次）

2，非静态资源（包括普通属性，构造器，匿名代码块（构造代码块））：父类执行完所有非静态资源然后再执行子类；（普通属性和匿名代码块在编译时会按上下顺序写在（每个）构造函数中的最前面，所以，）会先按普通属性和匿名代码块的上下顺序执行，最后执行构造函数中的代码

 

简单实例：

package com.briup.ch26;

public class TestDAIMAKUAI {
	public static void main(String[] args){
		System.out.println("运行TestDAIMAKUAI中的main函数，创建D类实例");
		new D();
	}
}



class E{
	E(){
		System.out.println("执行E的构造函数");
	}
	
	public void funcOfE(){
		System.out.println("执行E的函数");
	}
}

class F11{
	F11(){
		System.out.println("执行F的构造函数");
	}
	
	public void funcOfF(){
		System.out.println("执行F的函数");
	}
}

class B{
	E e=new E();
	static F11 f=new F11();
	public String sb=getSb();
	static{
		System.out.println("执行B类的static块(B包含E类的成员变量,包含静态F类成员变量)");
		f.funcOfF();
	}

	B(){
		System.out.println("执行B类的构造函数(B包含E类的成员变量,包含静态F类成员变量)");
		e.funcOfE();
	}

	{
		System.out.println("执行B实例的普通初始化块");
	}
	
	public String getSb(){
		System.out.println("初始化B的实例成员变量sb");
		return "sb";
	}
}

class C extends B{
	static{
		System.out.println("执行C的static块(C继承B)");
	}
	{
		System.out.println("执行C的普通初始化块");
	}
	
	C(){
		System.out.println("执行C的构造函数(C继承B)");
	}
}

class D extends C{
	public static String sd=getSd();
	static{
		System.out.println("执行D的static块(D继承C)");
	}

	D(){
		System.out.println("执行D的构造函数(D继承C);父类B的实例成员变量sb的值为："+sb+";本类D的static成员变量sd的值为："+sd+";本类D的实例成员变量sd1的值是："+sd1);
	}
	

	static public String getSd(){
		System.out.println("初始化D的static成员变量sd");
		return "sd";
	}

	public String getSd1(){
		System.out.println("初始化D的实例成员变量sd1");
		return "sd1";
	}
	{
		System.out.println("执行D实例的普通初始化块");
	}
	public String sd1=getSd1();
	
	int a = 5;
}

运行结果：

运行TestDAIMAKUAI中的main函数，创建D类实例
执行F的构造函数
执行B类的static块(B包含E类的成员变量,包含静态F类成员变量)
执行F的函数
执行C的static块(C继承B)
初始化D的static成员变量sd
执行D的static块(D继承C)
执行E的构造函数
初始化B的实例成员变量sb
执行B实例的普通初始化块
执行B类的构造函数(B包含E类的成员变量,包含静态F类成员变量)
执行E的函数
执行C的普通初始化块
执行C的构造函数(C继承B)
执行D实例的普通初始化块
初始化D的实例成员变量sd1
执行D的构造函数(D继承C);父类B的实例成员变量sb的值为：sb;本类D的static成员变量sd的值为：sd;本类D的实例成员变量sd1的值是：sd1

 

D.class

package com.briup.ch26;

import java.io.PrintStream;

class D extends C
{
  public static String sd = getSd();
  public String sd1;
  int a;

  static
  {
    System.out.println("执行D的static块(D继承C)");
  }

  D()
  {
    System.out.println("执行D实例的普通初始化块");

    this.sd1 = getSd1();

    this.a = 5;

    System.out.println("执行D的构造函数(D继承C);父类B的实例成员变量sb的值为：" + this.sb + ";本类D的static成员变量sd的值为：" + sd + ";本类D的实例成员变量sd1的值是：" + this.sd1);
  }

  public static String getSd()
  {
    System.out.println("初始化D的static成员变量sd");
    return "sd";
  }

  public String getSd1() {
    System.out.println("初始化D的实例成员变量sd1");
    return "sd1";
  }
}

从这个class文件就可以看出，普通属性和匿名代码块会放在构造器中