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、最后执行构造器，构造器执行完毕，对象生成。