1. package cn.my;
   
2. 
   
3. class Person{
   
4.         private String name;
   
5.         private int age;
   
6. 
   
7.         Person (){
   
8.                 System.out.println("父类空参数的构造方法！");
   
9.         }
   
10.        
    
11.         Person (String name,int age){
    
12.                 this.name = name;
    
13.                 this.age = age;
    
14.                 System.out.println("父类有参数的构造方法！");
    
15.         }
    
16. }
    
17. 
    
18. class Student extends Person{
    
19.         private int id;
    
20.         Student (String name,int age,int id){
    
21.                 //super(name,age);
    
22.                 this.id = id;
    
23.                 //super(name,age);
    
24.                 System.out.println("子类的构造方法！");
    
25. }
    
26. }
    
27. 
    
28. class Test2{
    
29.         public static void main (String[] agrs){
    
30.                 Student s = new Student("wangsan",12,123);
    
31.                
    
32.         }
    
33. }
    
34. 
    
35. 
    

复制代码

运行结果：父类空参数的构造方法！
子类的构造方法！
当第一条super存在时，自动将参数回传到有参父类构造方法，程序执行结果：

执行了父类有参构造方法！

子类构造方法执行！

当第二条super存在时，系统编译错误，调用父类构造方法必须为第一行。

1. package cn.my;
   
2. 
   
3. class Static1{
   
4.         Static1 (){
   
5.                 System.out.println("父类构造函数！");
   
6.         }
   
7.         static{
   
8.                 System.out.println("父类静态");
   
9.         }
   
10.         {
    
11.                 System.out.println("父类构代码块！");
    
12.         }
    
13. }
    
14. 
    
15. class Static2 extends Static1{
    
16.         Static2(){
    
17.                 System.out.println("子类构造函数！");
    
18.         }
    
19.         static{
    
20.                 System.out.println("子类静态");
    
21.         }
    
22.         {
    
23.                 System.out.println("子类构造代码块！");
    
24.         }
    
25. }
    
26. 
    
27. class Static3{
    
28.         static {
    
29.                 System.out.println("static3的静态构造代码块");
    
30.         }
    
31.         static void show(){
    
32.                 System.out.println("static3的show");
    
33.         }
    
34. }
    
35. 
    
36. class Test3 {
    
37.         public static void main(String[] ages){
    
38.                 new Static2();
    
39.                 Static3.show();
    
40.         }
    
41. 
    
42. }
    

复制代码

运行结果：
父类静态
子类静态
父类构代码块！
父类构造函数！
子类构造代码块！
子类构造函数！
static3的静态构造代码块
static3的show

总结：通过此段代码可以了解，随着类的加载静态代码块最先执行，子类的静态代码块优先于父类的构造代码块。父类的构造方法要优先于子类的构造代码块，当父类的构造代码块和构造函数完全执行完，才会执行子类的构造代码块、构造函数。

先执行静态代码块 后是代码块 最后是 构造函数