JAVA构造函数在超类与子类定义鲁波总结

1.子类无构造函数，超类无构造函数，创建的无参数的对象：

编译通过。

 1  class A
 2 {  
 3     
 4 }
 5 
 6  class B extends A
 7 {  
 8     
 9 }
10   public class Testeeer
11 {  
12     public static void main(String [] args)
13      {  
14        B b_01=new B();    
15       }  
16 }

2.子类有无参数构造函数，超类无构造函数，创建的无参数的对象：

运行结果：

调用了B的无参构造函数

 1  class A
 2 {  
 3 
 4 }
 5  class B extends A
 6 {  
 7    public B()
 8   {  
 9       System.out.println("调用了B的无参构造函数");  
10    }   
11 }
12 
13   public class Testeeer
14 {  
15     public static void main(String [] args)
16      {  
17        B b_01=new B();  
18         
19       }  
20 }

3.子类无构造函数，超类有无参数构造函数，创建的无参数的对象：

运行结果：

调用了A的无参构造函数

 1  class A
 2 {  
 3  public A()
 4   {  
 5       System.out.println("调用了A的无参构造函数");  
 6    } 
 7 }
 8  class B extends A
 9 {  
10     
11 }
12 
13   public class Testeeer
14 {  
15     public static void main(String [] args)
16      {  
17        B b_01=new B();  
18         
19       }  
20 }

4.子类有无参数构造函数，超类有无参数构造函数，创建的无参数的对象：

运行结果：

调用了A的无参构造函数

调用了B的无参构造函数

 1  class A
 2 {  
 3  public A()
 4   {  
 5       System.out.println("调用了A的无参构造函数");  
 6    } 
 7 }
 8  class B extends A
 9 {  
10  public B()
11   {  
12       System.out.println("调用了B的无参构造函数");  
13    }    
14 }
15 
16   public class Testeeer
17 {  
18     public static void main(String [] args)
19      {  
20        B b_01=new B();  
21         
22       }  
23 }

5.子类无构造函数，超类无构造函数，创建的有参数的对象：

编译不成功：

 1  class A
 2 {  
 3      
 4 }
 5 
 6 class B extends A
 7 {  
 8   
 9 }
10 
11   public class Testeeer
12 {  
13     public static void main(String [] args)
14      {  
15          
16        B b_02=new B("你好");  
17       }  
18 }

6.子类有无参数构造函数，超类无构造函数，创建的有参数的对象：

编译不成功：

 1  class A
 2 {  
 3      
 4 }
 5 
 6 class B extends A
 7 {  
 8   public B()
 9   {  
10       System.out.println("调用了B的无参构造函数");  
11     } 
12  }
13 
14   public class Testeeer
15 {  
16     public static void main(String [] args)
17      {  
18          
19        B b_02=new B("你好");  
20       }  
21 }

7.子类无构造函数，超类有无参数构造函数，创建的有参数的对象：

编译不成功：

 1  class A
 2 {  
 3   public A()
 4   {  
 5       System.out.println("调用了A的无参构造函数");  
 6     }    
 7 }
 8 
 9 class B extends A
10 {  
11   
12  }
13 
14   public class Testeeer
15 {  
16     public static void main(String [] args)
17      {  
18          
19        B b_02=new B("你好");  
20       }  
21 }

8.子类有无参数构造函数，超类有无参数构造函数，创建的有参数的对象：

编译不成功：

 1  class A
 2 {  
 3   public A()
 4   {  
 5       System.out.println("调用了A的无参构造函数");  
 6     }    
 7 }
 8 
 9 class B extends A
10 {  
11   public B()
12   {  
13       System.out.println("调用了B的无参构造函数");  
14     }  
15  }
16 
17   public class Testeeer
18 {  
19     public static void main(String [] args)
20      {  
21          
22        B b_02=new B("你好");  
23       }  
24 }

9.子类有有参数构造函数，超类无构造函数，创建的有参数的对象：

编译成功；

运行结果：

 1 class A
 2 {  
 3      
 4  }
 5  class B extends A
 6 {  
 7    
 8    public B(String mess)
 9    {  
10      System.out.println("调用了B的有参构造函数
"+  
11          "参数内容为："+mess);  
12     }  
13 
14 }
15 
16   public class Testeeer
17 {  
18     public static void main(String [] args)
19      {   
20        B b_02=new B("你好");  
21       }  
22 }

10.子类有有参数构造函数，超类有有参数构造函数，创建的有参数的对象：

编译失败：

 1 class A
 2 {  
 3   public A(String mess)
 4    {  
 5      System.out.println("调用了A的有参构造函数
"+  
 6          "参数内容为："+mess);  
 7     }   
 8  }
 9  class B extends A
10 {  
11    
12    public B(String mess)
13    {  
14      System.out.println("调用了B的有参构造函数
"+  
15          "参数内容为："+mess);  
16     }  
17 
18 }
19 
20   public class Testeeer
21 {  
22     public static void main(String [] args)
23      {   
24        B b_02=new B("你好");  
25       }  
26 }

11.子类有有参数构造函数（首行定义super），超类有有参数构造函数，创建的有参数的对象：

编译成功；

运行结果：

 1 class A
 2 {  
 3   public A(String mess)
 4    {  
 5      System.out.println("调用了A的有参构造函数
"+  
 6          "参数内容为："+mess);  
 7     }   
 8  }
 9  class B extends A
10 {  
11    
12    public B(String mess)
13    {  
14      super(mess);
15      System.out.println("调用了B的有参构造函数
"+  
16          "参数内容为："+mess);  
17     }  
18 
19 }
20 
21   public class Testeeer
22 {  
23     public static void main(String [] args)
24      {   
25        B b_02=new B("你好");  
26       }  
27 }

12.子类有有参数构造函数，超类有有参数构造函数和无参数的构造函数，创建的有参数的对象：

编译成功；

运行结果：

 1 class A
 2 {  
 3   public A(String mess)
 4    {  
 5      System.out.println("调用了A的有参构造函数
"+  
 6          "参数内容为："+mess);  
 7     } 
 8    public A()
 9     {  
10       System.out.println("调用了A的无参构造函数");  
11      }   
12  }
13  class B extends A
14 {  
15    
16    public B(String mess)
17    {  
18      
19      System.out.println("调用了B的有参构造函数
"+  
20          "参数内容为："+mess);  
21     }  
22 
23 }
24 
25   public class Testeeer
26 {  
27     public static void main(String [] args)
28      {   
29        B b_02=new B("你好");  
30       }  
31 }

13.子类有有参数构造函数，超类默认无构造函数，创建的有参数的对象：

编译成功；

运行结果：

 1 class A
 2 {  
 3     
 4  }
 5  class B extends A
 6 {  
 7    
 8    public B(String mess)
 9    {  
10      
11      System.out.println("调用了B的有参构造函数
"+  
12          "参数内容为："+mess);  
13     }  
14 
15 }
16 
17   public class Testeeer
18 {  
19     public static void main(String [] args)
20      {   
21        B b_02=new B("你好");  
22       }  
23 }

1.一旦你在超类或者子类中定义了有参数的构造函数，那么子类和超类中系统默认提供的无参构造函数将不复存在。

2.在子类的构造函数构造前，一定要完成超类的构造函数构造的过程。（那么依据这样的惯性行为，主程序入口处创建的对象的两种类型（有参数或者无参数）将会直接决定子类所调用的构造函数类型（与对象的类型相同）（有参数或者无参数），但是在完成子类构造函数前，先要去完成超类的构造函数。）

2.1如果是无参数的对象创建：

2.1.1超类：默认子类：无参构造函数运行：超类默认，子类无参构造

2.1.2超类：无参构造函数子类：默认运行：超类无参构造函数，子类默认

2.1.3超类：默认子类：默认运行：超类默认，子类默认

2.1.4超类：无参构造函数子类：无参构造函数运行：超类无参构造函数，子类无参构造函数

2.2如果是有参数的对象创建：

2.2.1超类：有参构造数子类:有参构造函数{定义中首行super（形参）} 运行：超类有参构造数，子类有参构造函数

2.2.2超类：默认子类:有参构造函数运行：超类默认，子类有参构造函数

2.2.3超类：无参构造数子类:有参构造函数运行：超类无参构造数，子类有参构造函数

2.2.4超类：有参构造和无参构造子类:有参构造函数运行：无参构造，子类有参构造函数

2.2.5超类：有参构造和无参构造子类:有参构造函数{定义中首行super（形参）} 运行：超类有参构造，子类有参构造函数