java继承的初始化机制

加载类的初始化过程

1 static属于类的变量，static方法属于类方法，他们都通过类名.方法/属性进行调用。在JVM加载类时，首先会从下到下加载类的static代码块或static变量（它们是按照上下顺序加载的）。对于static方法也加载了，但是没有具体的实现。我的理解就是：static方法的加载和其他的方法加载都会在类被JVM加载的，但是只是加载了一个引用（这里不是类的引用而是方法的引用，就好像接口声明了一个方法差不多），并没有具体的实现，当通过类名+static方法的时候，static方法才会被真正的加载，普通方法在new class（）+方法调用的时候才会被真正的初始化。
调用顺序如果有继承的话：父类的静态代码块->子类的静态代码块->父类的静态变量->子类的静态变量->父类的普通初始化对象->子类的普通初始化对象->父类构造方法->子类构造方法！

代码Father父类！

package com.demo.ex.demo;

/**
 * 子类继承父类的加载过程
 * 
 * @author dan.wang
 *
 */
public class Father {
    static ExternalConfig ec = new ExternalConfig("father's static param");
    @SuppressWarnings("unused")
    private String name;
    @SuppressWarnings("unused")
    private String age;

    static {
        System.out.println("Father's static field");
    }

    public Father() {
        System.out.println("Faher constructure");
        // display();
    }

    ExternalConfig ecc = new ExternalConfig("father' param no static");

    public Father(String name, String age) {
        this.name = name;
        this.age = age;
        System.out.println("Faher two params constructure");
    }

    public static void fatherSMA() {
        System.out.println("Father's static MA");
    }

    public void fatherMa() {
        System.out.println("Father's MA");
    }

    /**
     * 这个方法是为了测试，当JVM加载父类的时候是否会支持加载类ExternalConfig
     * 
     * @return
     */
    public ExternalConfig externalMA() {
        System.out.println("Father externalMA");
        return new ExternalConfig().getExternalInstance();
    }

    /**
     * 重载的方法
     * 
     * @param name
     */
    public void overDemo1(String name) {
        System.out.println("father's demo01 " + name);
    }

    public void overDemo1() {
        overDemo1("param method overDemo1");
        System.out.println("father's no param method overDemo1");
    }

    /**
     * 在父类构造方法中调用这个方法，子类会重写这个方法
     */
    public void display() {
        System.out.println("father's display");
    }
}

加载类Father时，并没有加载出这个externalMA()方法，只有在类实例调用的时候才会加载这个返回的ExternalConfig类 

son的代码

package com.demo.ex.demo;

public class Son extends Father {

    static ExternalConfig ec = new ExternalConfig("son's static param");
    ExternalConfig ecc = new ExternalConfig("son's param no static");
    static {
        System.out.println("Son static field");
    }

    public Son() {
        System.out.println("son's constructure");
    }

    public Son(String name, String age) {
        System.out.println("son's two params constructure");
    }

    @Override
    public void overDemo1(String name) {
        System.out.println("son's demo01 " + name);
        super.overDemo1("son's param");
    }

    @Override
    public void overDemo1() {
        System.out.println("son no param method overDemo1");
        super.overDemo1();
    }

    @Override
    public void display() {
        System.out.println("son's display");
    }

    /**
     * 子类继承父类之后，子类独有的方法
     */
    public void sonMA() {
        System.out.println("son's own method");
    }
}

ExternalConfig类

package com.demo.ex.demo;

public class ExternalConfig {

    static {
        System.out.println("ExternalConfig static field");
    }

    public ExternalConfig() {
        System.out.println("ExternalConfig constructure");
    }

    public ExternalConfig(String name) {
        System.out.println("ExternalConfig constructure " + name);
    }

    public void getExternal() {
        System.out.println("ExternalConfig getExternal method");
    }

    public ExternalConfig getExternalInstance() {
        return new ExternalConfig();
    }
}

测试类

public class Test {

    public static void main(String[] args) {

        /**
         * 1 测试类的家在顺序
         */
        new Son();
        /**
         * 2 子类的实例调用重写父类的方法
         */
        // new Son().overDemo1();
        /**
         * 3 父类的实例直接调用父类的方法
         */
        // new Father().overDemo1();
        /**
         * 4 父类的引用指向子类的对象，调用子类扩展的功能
         */
        // Father f = new Son();
        // f.sonMA();
        /**
         * 子类的实例调用子类扩展的功能
         */
        // new Son().sonMA();
    }
}

真正调用方法或者属性的是类的实例而不是引用

真正调用方法或者属性的是类的实例而不是引用，引用只是一个导入作用，找到真正的实例。用下面的几句话解释上面测试的2、3、4。
Father f = new Son();
f引用可以用所有父类中的方法，无法调用子类特有的方法。当子类重写了父类的方法时，引用f调用的就是子类中重写的方法，而不是父类的方法。因为f仅仅是一个引用而不是对象，调用类的属性和方法其实实质是通过类的实例进行调用的，f是父类的引用而真正的实例是子类的的实例，所以f无法调用子类特有的方法。继承的时候子类中继承了类中可以继承的所有方法和属性（特殊修饰除外），如果子类重写了父类的方法，子类的实例肯定调用的是子类中重写的方法。

子类的实例new Son()首先调用 overDemo1()方法;
然后在子类的overDemo1()方法中调用父类的overDemo1()方法。
执行测试2的部分结果

son no param method overDemo1
son's demo01 param method overDemo1
father's demo01 son's param
father's no param method overDemo1

实例会先调用子类的方法，然后再去调用父类的方法，在父类中调用的overDemo1(“param method overDemo1”)方法虽然是在父类里面直接调用的，但是归根揭底还是子类实例调用的，所以先调用子类重写的方法！

    @Override
    public void overDemo1(String name) {
        System.out.println("son's demo01 " + name);
        super.overDemo1("son's param");
    }
    Son的代码方法
    @Override
    public void overDemo1() {
        System.out.println("son no param method overDemo1");
        super.overDemo1();
    }

    /**
     * 重载的方法
     * 
     * @param name
     */
    public void overDemo1(String name) {
        System.out.println("father's demo01 " + name);
    }
    father的代码方法
    public void overDemo1() {
        overDemo1("param method overDemo1");
        System.out.println("father's no param method overDemo1");
    }