java类初始化以及实例的初始化

首先定义一个父类

/**
 * @author Fbin
 * @date 2020/3/12
 * @annotation 高山仰止, 景行行止.虽不能至, 心向往之
 */
public class Father {
	//成员变量
    public int i = test();
    //静态成员变量
    public static int j = method();
    //静态代码块
    static {
        System.out.print("(1)");
    }
    //父类构造方法
    public Father() {
        System.out.print("(2)");
    }
    //代码块
    {
        System.out.print("(3)");
    }
    public int test() {
        System.out.print("(4)");
        return 1;
    }
    public static int method() {
        System.out.print("(5)");
        return 1;
    }
}

接着创建一个子类对象，继承父类。并创建main方法，如下：

/**
 * @author Fbin
 * @date 2020/3/12
 * @annotation 高山仰止, 景行行止.虽不能至, 心向往之
 */
public class Son extends Father{
    //成员变量
    public int i = test();
    //静态成员变量
    public static int j = method();
    //静态代码块
    static {
        System.out.print("(6)");
    }
    //子类构造
    public Son() {
        System.out.print("(7)");
    }
    //代码块
    {
        System.out.print("(8)");
    }
    public int test() {
        System.out.print("(9)");
        return 1;
    }
    public static int method() {
        System.out.print("(10)");
        return 1;
    }
    public static void main(String[] args) {
    }
}

此时执行main方法，控制台打印如下结果

原因：

调用main（）方法，会进行子类的初始化（调用<clinit>方法）
1、 public static int j = method();
2、子类的静态代码块
static {
        System.out.print("(6)");
}

还有一个规则

先进行父类的初始化
再初始化子类

所以现在的执行顺序也就是

1、 父类的静态变量
public static int j = method();
public static int method() {
     System.out.print("(5)");
     return 1;
}
2、子类的静态代码块
static {
        System.out.print("(1)");
}
3、 子类的静态变量
public static int j = method();
public static int method() {
     System.out.print("(10)");
     return 1;
}
4、子类的静态代码块
static {
        System.out.print("(6)");
}

总结以下：

1、一个类要创建实例需要先加载并初始化该类
	main方法所在的类需要先加载和初始化
2、一个子类需要初始化需要先初始化父类
3、一个类初始化就是执行<clinit>()方法
	<clinit>()方法有静态类变量显示赋值代码和静态代码块组成
	类变量显示赋值代码和静态代码块代码从上到下依次顺序执行
	<clinit>()只执行一次

现在在Son类的main方法中加上以下代码，此时Son类如下

/**
 * @author Fbin
 * @date 2020/3/12
 * @annotation 高山仰止, 景行行止.虽不能至, 心向往之
 */
public class Son extends Father{
    //成员变量
    public int i = test();
    //静态成员变量
    public static int j = method();
    //静态代码块
    static {
        System.out.print("(6)");
    }
    //子类构造
    public Son() {
        System.out.print("(7)");
    }
    //代码块
    {
        System.out.print("(8)");
    }
    public int test() {
        System.out.print("(9)");
        return 1;
    }
    public static int method() {
        System.out.print("(10)");
        return 1;
    }
    public static void main(String[] args) {
        System.out.println("\n开始创建第一个实例s1");
        Son s1 = new Son();
        System.out.println("\n开始创建第二个实例s2");
        Son s2 = new Son();
    }
}

可以看见，在main方法中进行了两次的实例化

子类的实例化：
1、super（）最前，也就是Father类
2、子类的非静态变量
public int i = test();
public int test() {
    System.out.print("(9)");
    return 1;
}
3、子类的非静态代码块
{
    System.out.print("(8)");
}
4、子类的无参构造（最后）
//子类构造
public Son() {
    System.out.print("(7)");
}
    
父类的实例化方法
1、super（）最前，Object类，此处没打印
2、父类的非静态变量
public int i = test();
//此处实际上是this调用，此时test方法已经被子类重写了，所以实际调用的是子类的
public int test() {
    System.out.print("(9)");
    return 1;
}
3、父类的非静态代码块
{
    System.out.print("(3)");
}
4、父类的无参构造（最后）
//父类构造方法
public Father() {
    System.out.print("(2)");
}
所以执行顺序也就是(9)(3)(2)(9)(8)(7)

打印结果如下

总结

1、实例初始化就是执行<init>()方法
	<init>()可能重载有多个，有几个构造器就有几个<init>()方法
	<init>()方法由非静态实例变量显示赋值代码和非静态代码块、对应构造器代码组成
	非静态实例变量显示赋值和非静态代码块代码从上到下顺序执行，而对应构造器的代码最后执行
	每次创建实例对象，调用对应构造器，执行的就是对应的<init>()方法
	<init>()方法的首行是super()或者super(实参列表)，即对应父类的<init>()方法
2、方法的重写
	1.哪些方法不可以被重写
			final方法
			静态方法
			private修饰的方法
	2.对象的多态性
			子类如果重写了父类的方法，通过子类对象调用的一定是子类重写过的代码
			非静态方法默认的调用对象是this
			this对象在构造器或者说<init>()方法中就是正在创建的对象