static变量、实例变量的初始化以及类加载顺序过程

public   class  Outer {
  2  
  3      
  4       public  Outer() {
  5          System.out.print("a"); // 构造方法，new的时候才会出现，且后于变量的创建
  6      }
  7      
  8      
  9      
 10       public   static   void  sayOther(String s){
 11          System.out.print(s);
 12      }
 13      
 14      
 15      
 16       public   int  say(String s){
 17          System.out.print(s);
 18           return  0;
 19      }
 20      
 21      
 22       // 初始化块，在new时，构造方法之前,变量之前执行
 23      {
 24          System.out.print("c");
 25          inner.innerMethed("d");
 26      }
 27      
 28      
 29       private   static  inner t=  new  inner(); // 静态变量，这些都是在类加载完之前就放于内存中，且只加载这一次，new类对象时是不会再次执行的了。
 30       static
 31      {
 32          System.out.print("e");
 33          inner.innerMethed("f"); // 静态初始化块，整个静态的都是在加载之前就做好初始化。
 34           new  inner();
 35      }
 36      
 37      
 38       private   int  i=say("g"); // 在new时，先于构造但是后于初始化块的一个实例变量，也即：实例对象：（实例初始化块，实例变量）--->构造方法
 39       private  inner tt= new  inner(); // 整个是在类加载ClassLoader之后初始化变量时，才做。每个new对象都会执行上面这个步骤
 40       private  innerOther ttt= new  innerOther();
 41      
 42      
 43      
 44       static   class  inner{
 45          
 46          
 47           public  inner(){
 48              System.out.print("h");
 49          }
 50          
 51          
 52           public   static   void  innerMethed(String s){
 53              System.out.print(s);
 54          }
 55          
 56          
 57          
 58          {
 59              System.out.print("i");
 60          }
 61          
 62          
 63          
 64           static
 65          {
 66              System.out.print("j");
 67          }
 68          
 69          
 70      }
 71      
 72      
 73      
 74       class  innerOther{
 75          
 76          
 77           public  innerOther(){
 78              System.out.print("k");
 79          }
 80          
 81          
 82          {
 83              System.out.print("l");
 84          }
 85          
 86          
 87          
 88      }
 89      
 90      
 91      
 92       public   static   void  main(String[] args) {
 93          System.out.print("m");
 94          Outer outer =  new  Outer();
 95          System.out.print("n");
 96          
 97           // 总结就是：类对象，变量的加载顺序
 98            // 在整个类加载完成之后，就初始化静态（静态变量，静态块），其中可以new对象，别的类调用静态方法。静态的只做这一次，然后类加载器ClassLoader就把类Class返还，执行main方法。
 99            // 在new类对象时，执行顺序是：（实例初始化块，实例变量）-->构造方法。每new一个对象时，都会执行这个步骤。
100           
101            // （静态变量、静态初始化块）—— 》 （变量、初始化块）—— 》 构造函数，（）中的内容是按照代码前后循序执行
102          
103            // 当有继承关系时，还是基于这个原理，如new Son（）；
104            // 父类的静态（块和变量）-->子类的静态（块和变量）-->父类的（块和变量+构造方法）-->子类的（块和变量+构造方法）
105            //
106      }
107  }

//类的是通过：装载，连接，初始化

//java程序在执行过程中，类，对象以及它们成员加载、初始化的顺序如下： 

//1、首先加载要创建对象的类及其直接与间接父类。 

//2、在类被加载的"同时"会将静态成员进行加载，主要包括静态成员变量的初始化，静态语句块的执行，在加载时按代码的先后顺序进行。 <clinit>

//3、需要的类加载完成后，开始创建对象，首先会加载非静态的成员，主要包括非静态成员变量的初始化，非静态语句块的执行，在加载时按代码的先后顺序进行。 

//4、最后执行构造器，构造器执行完毕，对象生成。