关于java:在继承当中这些方法及代码块执行顺序是什么样的

在 Java 中，尤其是咱们的 Java 根底中，咱们会学习到咱们的动态代码块，结构代码块，部分代码块，也会学习到构造方法和不同办法，那么这些执行程序是什么样呢，咱们上面来一起看一看：
咱们这里须要创立两个类，别离是 Person（一般类），Demo（测试类）

Person（一般类）

public class Person {
    static {System.out.println("动态代码块");
    }

    {System.out.println("结构代码块");
    }

    public Person (){System.out.println("构造方法");
    }

    public void Common(){System.out.println("一般办法");
        {System.out.println("部分代码块");
        }
    }
}

Demo（测试类）

public class Demo {public static void main(String[] args) {
        /**
         * Person p = new Person();
         *   动态代码块
         *   结构代码块
         *   构造方法
         * p.Common();
         *   一般办法
         *   部分代码块
         */
        Person p = new Person();
        p.Common();
        /**
         * 再这里咱们发现了一个问题，当咱们第二次创建对象的时候咱们的动态代码块没有呈现，那么这个是为什么呢？* 在这里咱们须要记住两件事件：* 1）当咱们第一次加载类的时候会执行咱们的动态代码块，临时能够了解为咱们在第一次创建对象时会执行一次，之后不会再次执行
         * 2）咱们的结构代码块，时在每次 new 对象之前都会执行一次
         * Person p2 = new Person();
         *   结构代码块
         *   构造方法
         * p2.Common();
         *   一般办法
         *   部分代码块
         */
        Person p2 = new Person();
        p2.Common();}
}

上述只是简略的代码块之前的程序，那么在咱们的继承关系中他们的执行程序又是什么样的呢，上面咱们再来测试以下：
咱们这里须要创立三个类，别离是 Super（父类），Sub（子类），Demo（测试类）

Super（父类）

public class Super {
    static {System.out.println("我是父类动态代码块");
    }

    {System.out.println("我是父类结构代码块");
    }

    public Super (){System.out.println("我是父类构造方法");
    }

    public void Common(){System.out.println("我是父类一般办法");
        {System.out.println("我是父类部分代码块");
        }
    }    
}

Sub（子类）

public class Sub extends Super{
    static {System.out.println("我是子类动态代码块");
    }

    {System.out.println("我是子类结构代码块");
    }

    public Sub (){System.out.println("我是子类构造方法");
    }

    // 重写了父类的 Common 办法
    public void Common(){System.out.println("我是子类重写后的一般办法");
        {System.out.println("我是子类重写后的部分代码块");
        }
    }
}

Demo（测试类）

public class Demo {public static void main(String[] args) {
        /* 每一段都是独自的 */
        /**
         * Super s = new Super();
         *   我是父类动态代码块
         *   我是父类结构代码块
         *   我是父类构造方法
         * s.Common();
         *   我是父类一般办法
         *   我是父类部分代码块
         */
        Super s = new Super();
        s.Common();
        /**
         * Sub a = new Sub();
         *   我是父类动态代码块
         *   我是子类动态代码块
         *   我是父类结构代码块
         *   我是父类构造方法
         *   我是子类结构代码块
         *   我是子类构造方法
         * a.Comm();
         *   我是子类一般办法
         *   我是子类部分代码块
         */
        Sub a = new Sub();
        a.Common();
        /**
         * Super sp = new Sub();
         *   是父类动态代码块
         *   我是子类动态代码块
         *   我是父类结构代码块
         *   我是父类构造方法
         *   我是子类结构代码块
         *   我是子类构造方法
         * sp.Common();
         *   是子类重写后的一般办法
         *   我是子类重写后的部分代码块
         */
        Super sp = new Sub();
        sp.Common();}
}