java类中方法的执行顺序

静态平级---->new的先执行代码块 再执行构造器，按照顺序执行

static{}代码块--->如果是static Test t1=new Test()

因为获得了new对象，先执行普通代码块（按照代码顺序），在执行构造器--->

如果是static int x=method()（method是静态方法）直接执行method方法中的内容-->如果后面再没有static修饰的内容执行main方法，其中如果再遇到new对象，还是先执行普通代码块，再按照代码顺序执行

具体看下面这串代码（简直是让人头大）

package com.sheen.first;

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

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

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

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

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

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

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 String sd1 = getSd1();
public static String sd = getSd();
static {
System.out.println("执行D的static块(D继承C)");
}
{
System.out.println("执行D实例的普通初始化块");
}

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";
}
}

结果：

运行ExaminationDemo中的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的实例成员变量sd1
执行D实例的普通初始化块
执行D的构造函数(D继承C);父类B的实例成员变量sb的值为：sb;本类D的static成员变量sd的值为：sd;本类D的实例成员变量sd1的值是：sd1