对象初始化过程细节

1.创建对象过程

 static{
                  静态代码块中的执行语句
         }
         
特点：随着类的加载而执行，只执行一次并优先于主函数。 用于给类进行初始化。

Persong   p  = new  Person("XX",XX);

这句话执行了：
   <1> 因为new用到了Person.class，所以会先找到Persong.class文件并加载到内存中
   <2> 执行该类中的static代码块，如果有的话，给Person.class类进行初始化
   <3> 在堆内存中开辟空间，分配内存地址
   <4> 在堆内存中建立对象特有属性，并进行默认初始化
   <5> 对属性进行初始化
   <6> 对对象进行构造代码块初始化
   <7> 对对象进行对应的构造函数初始化
   <8> 将内存地址赋给栈内存中的p变量
   

2.父子间对象初始化过程

对象的初始化顺序:

  1.首先执行父类静态的内容，父类静态的内容执行完毕后;
  2.接着去执行子类的静态的内容，当子类的静态内容执行完毕之后;
  3.再去看父类有没有非静态代码块，如果有就执行父类的非静态代码块,父类的非静态代码块执行完毕;
  4.接着执行父类的构造方法,父类的构造方法执行完毕之后;
  5.它接着去看子类有没有非静态代码块，如果有就执行子类的非静态代码块,子类的非静态代码块执行完毕;
  6.去执行子类的构造方法。
  
  总之一句话，静态代码块内容先执行，接着执行父类非静态代码块和构造方法，
  然后执行子类非静态代码块和构造方法。

注意:子类的构造方法，不管这个构造方法带不带参数，默认的它都会先去寻找父类的不带参数的构造方法。
如果父类没有不带参数的构造方法，那么子类必须用supper关键子来调用父类带参数的构造方法，否则编译不能通过。
   

　　代码演示：

class Father
{
    int nonFatherStaticVar = nonFatherStaticShow();//父类非静态变量
    static int father = FatherStaticShow();//父类静态变量
    static //父类静态代码块
    {
        System.out.println("父亲的static代码块运行了");
    }
    public int nonFatherStaticShow(){
        System.out.println("父类非静态变量初始化");
        return 1;
    }
    public static int FatherStaticShow(){
        System.out.println("父类静态变量初始化");
        return 2;
    }
    public Father()//父类构造方法
    {
        System.out.println("父亲的构造函数运行了");
    }
    static void show(){
        System.out.println("父亲普通方法运行了");
    }
    
}
class Son extends Father
{    
    int nonSonStaticVar = nonSonStaticShow();//子类非静态变量
    static int son = SonStaticShow();//子类静态变量
    static //子类静态代码块
    {
        System.out.println("子类的static代码块运行了");
    }
    public int nonSonStaticShow(){
        System.out.println("子类非静态变量初始化");
        return 1;
    }
    public static int SonStaticShow(){
        System.out.println("子类静态变量初始化");
        return 2;
    }
    public Son()//父类构造方法
    {
        System.out.println("子类的构造函数运行了");
    }
    
}

public class InitDemo
{    
    public static void main(String[] args)
    {
        Son son = new Son();
        son.show();
    }
}

/*
    继承中，父子类间的初始化顺序:
    
    1、父类的静态代码块和静态变量初始化
    2、子类静态代码块和静态变量初始化
    3、父类非静态变量初始化
    4、父类构造函数运行
    5、子类非静态变量初始化
    6、子类的构造函数运行
*/

3.静态代码块不是在类加载时被调用的，而是第一个实例对象被创建时才执行的

/*
需求：测试构造代码块、静态构造代码块的执行顺序。
*/

class StaticCode1
{
        static
        {
                System.out.println("StaticCode1——————静态代码块"); 
        }
        {
                System.out.println("StaticCode1————————代码块"); 
        }
}

class StaticCode
{
        static
        {
                System.out.println("3。StaticCode*************静态代码块——————"); 
        }
        {
                System.out.println("StaticCode************代码块————————"); 
        }
}

class StaticCodeDemo
{
        static
        {
                System.out.println("1。StaticCodeDemo静态代码块1"); 
        }
        {
                System.out.println("StaticCodeDemo代码块"); 
        }
        public static void main(String[] args) 
        {
                //连续创建两个StaticCode类的对象，静态代码块之执行一次，非静态代码块执行两次
                new StaticCode();
                new StaticCode();

                //同一个类中有多个静态代码块，按由上到下顺序执行
                new StaticCodeDemo();

                //StaticCode1类已经加载，但是代码块却没有运行；
                StaticCode1 code1=null;
                StaticCode1 code12;

                System.out.println("over"); 
        }
        static
        {
                System.out.println("2。StaticCodeDemo静态代码块2"); 
        }
}

程序的运行是：先创建main函数所在类的对象然后才找到main函数执行。