Java学习笔记day07——类中方法的执行顺序比较

    static{}代码块—>如果是static Test t1 ＝ new Test()
    因为获得了new对象,先执行普通代码块(按照代码顺序)，再执行构造器
    —>如果是static int x =  method()(method是静态方法)
    直接执行method方法中的内容—>如果后面再没有static修饰的内容
    执行main方法,其中如果再遇到new对象,还是先执行普通代码块,再执行构造器

public class OrderTest
   {   
       //静态永远先加载
       //如果是静态方法,也会先执行 
       //改成静态，就会先走实例代码块
       static int num = 4;
       //改成静态，就会先走实例代码块
      static OrderTest ot = new OrderTest();
      {
          num += 3;
          System.out.println("b");
      }
      int a = 5;                  
      {
          //先执行int 再执行地下
          System.out.println("a:"+a);
          System.out.println("c");
      }
      public OrderTest()          
      {
          System.out.println("d");
      }
      public OrderTest(String s)  
      {
          System.out.println(s+"");
      }
      //main什么都不写也会输出    
      static                      
      {
          System.out.println("num"+num);
          System.out.println("a");
      }
      static void run()           
      {
          System.out.println("e");
      }
      public static void main(String[] args)
      {
          //先走实例代码块,然后走实例代码块,再走构造器
          OrderTest ot = new OrderTest();
          //静态只执行一次，但其他new一次执行一次
          OrderTest ot1 = new OrderTest();
      }
  }

总结：

代码执行顺序
1.静态
    静态跟随类的创建而加载
    如果同样是静态，按照声明顺序加载
    当然，如果是继承于父类，就先找父类的静态，之后再子类的静态
2.父类实例/代码块
3.父类构造器
4.子类实例/代码块
5.子类的构造器

所以，构造器理论上是在实例之后再加载，但是实际运行起来其实是构造器在实例之前加载 

public class OrderTest
	Test t = new Test();
	public static void main(String[] args)
	{
		new OrderTest;
	}

	public OrderTest()
	{
		System.out.println("这是无参构造器");
	}
	class Test
	{
		public Test()
		{
			System.out.println("Test的无参构造器");
		}
	}

    最后结果是先输出了Test的无参构造器,即构造器先于实例执行
    在利用反编译软件反编译之后，因为定义的变量是在构造器之中完成的，所以并不是构造器先于实例执行