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

 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 }  

 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 }  

 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 } 

 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 }

 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 } 

 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 }  

 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 }  

 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 }  

 1 class A
 2 {  
 3      
 4  }
 5  class B extends A
 6 {  
 7    
 8    public B(String mess)
 9    {  
10      System.out.println("调用了B的有参构造函数\n"+  
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 }

 1 class A
 2 {  
 3   public A(String mess)
 4    {  
 5      System.out.println("调用了A的有参构造函数\n"+  
 6          "参数内容为："+mess);  
 7     }   
 8  }
 9  class B extends A
10 {  
11    
12    public B(String mess)
13    {  
14      System.out.println("调用了B的有参构造函数\n"+  
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 } 

 1 class A
 2 {  
 3   public A(String mess)
 4    {  
 5      System.out.println("调用了A的有参构造函数\n"+  
 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的有参构造函数\n"+  
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 }