再探Java中的继承加载顺序

public class test2 {     static class a {        int x = 999;        int y = 999;        {            System.out.println("a--父类非静态方法");        }        static {            System.out.println("a--父类静态方法");        }        // public a() {        //     System.out.println("a--执行a类无参构造方法");        // }        public a(int x) {            System.out.println("a--执行父类有参构造方法");        }        public void print() {            System.out.println("a--我是父类的打印方法");        }    }    static class b extends a {        int x = 1;        int y;        {            System.out.println("b--子类非静态方法");        }        static {            System.out.println("b--子类静态方法");        }        // public b() {        //     super();        //     System.out.println("b--执行b类无参构造方法");        //     //y = -1;        // }        public b(int x) {            super(1);            System.out.println("b--执行子类有参构造方法");        }        public void print() {            System.out.println("b--在子类中调用父类的super方法");            super.print();            System.out.println("b--我是子类的打印方法");        }    }    public static void main(String[] args) {        // TODO Auto-generated method stub        int x = 0;        new b(x);        //a.print();    }}

如图，这样加载顺序，先加载的都是静态块，先父类后子类。然后加载父类的非静态方法和构造器，然后子类的非静态方法和构造器

执行顺序大体上可以说是先父类后子类，父类static域 ==》子类static域 ==》父类数据成员域 ==》父类构造器 ==》子类数据成员域 ==》子类构造器。而且从结果中我们还可以看到，无论实例化多少个对象，static 域仅有一份，而且只执行一次。

注意第三十九行代码：这里显式调用了父类的有参构造，不加的话会默认调用无参的，如果父类没写无参的就会报错

第二个：

    public class test1 {         static class a {            int x = 999;            int y = 999;            {                System.out.println("a--父类非静态方法");            }            static {                System.out.println("a--父类静态方法");            }            public a() {                System.out.println("a--执行a类无参构造方法");                print();            }            public a(int x) {                System.out.println("a--执行父类有参构造方法");            }            public void print() {                System.out.println("a--我是父类的打印方法");            }        }        static class b extends a {            int x = 1;            int y;            {                System.out.println("b--子类非静态方法");            }            static {                System.out.println("b--子类静态方法");            }            public b() {                System.out.println("b--执行b类无参构造方法");                //y = -1;            }            public b(int x) {                // super(1);                //不写是默认生成的super(),无参数的                System.out.println("b--执行子类有参构造方法");            }            public void print() {                System.out.println("b--在子类中调用父类的super方法");                super.print();                System.out.println("b--我是子类的打印方法");            }        }        public static void main(String[] args) {            // TODO Auto-generated method stub            int x = 0;            a a1 = new a(x);            a1.print();            System.out.println();            b b1 = new b(x);            // a.print();        }    }

输出如图：

第二个声明了子类的对象，因为print()，在子类中被重写了。所以调用的是子类的重写后的print方法。但是还是可以通过super访问父类的这个被重写的方法。

子类的构造器必须要调用父类的构造器才能完成初始化，默认的是super()，没有参数的，也就是会默认调用父类无参数的构造器

第三个：

    public class test1 {         static class a {            int x = 999;            int y = 999;            {                System.out.println("a--父类非静态方法");            }            static {                System.out.println("a--父类静态方法");            }            // public a() {            //     System.out.println("a--执行a类无参构造方法");            //     print();            // }            public a(int x) {                System.out.println("a--执行父类有参构造方法");            }            public void print() {                System.out.println("a--我是父类的打印方法");            }        }        static class b extends a {            int x = 1;            int y;            {                System.out.println("b--子类非静态方法");            }            static {                System.out.println("b--子类静态方法");            }            public b() {                 super(0);                System.out.println("b--执行b类无参构造方法");                //y = -1;            }            public b(int x) {                super(1);                //不写是默认生成的super(),无参数的                System.out.println("b--执行子类有参构造方法");            }            public void print() {                System.out.println("b--在子类中调用父类的super方法");                super.print();                System.out.println("b--我是子类的打印方法");            }        }        public static void main(String[] args) {            // TODO Auto-generated method stub            int x = 0;            // a a1 = new a(x);            // a1.print();            System.out.println();            b b1 = new b(x);            // a.print();        }    }

       如果注释了父类的无参构造，但是子类还有有无参构造，我现在创建的是子类有参的对象，还是会报错。为什么？问了杨学长，语法规定就是这样，就算这个b子类无参构造没有实际加载(打印信息没有打印)，只要你写了子类的构造，你就必须要为这个构造方法负责，不管在之后对象有没有用到。注释了父类无参构造的话，可以在b子类无参构造这里加一个super(0)，调用父类有参的构造，必须要特别这样声明才行，不声明编译器会找父类无参，无参又没有，所以报错。

       编译器按照Java语言的规范把源码编译成字节码文件，然后JVM加载这个类，初始化等一系列操作调用它的main方法。所以说编译的时候会检查你的语法是否正确，不是说不用就检查了，编译时能发现的错误，不会拖延到运行时才知道