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

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

  编译通过。

 class A
{  
    
}

 class B extends A
{  
    
}
  public class Testeeer
{  
    public static void main(String [] args)
     {  
       B b_01=new B();    
      }  
}  

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

运行结果：

调用了B的无参构造函数

 class A
{  

}
 class B extends A
{  
   public B()
  {  
      System.out.println("调用了B的无参构造函数");  
   }   
}

  public class Testeeer
{  
    public static void main(String [] args)
     {  
       B b_01=new B();  
        
      }  
}  

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

运行结果：

调用了A的无参构造函数

 class A
{  
 public A()
  {  
      System.out.println("调用了A的无参构造函数");  
   } 
}
 class B extends A
{  
    
}

  public class Testeeer
{  
    public static void main(String [] args)
     {  
       B b_01=new B();  
        
      }  
} 

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

运行结果：

调用了A的无参构造函数

调用了B的无参构造函数

 class A
{  
 public A()
  {  
      System.out.println("调用了A的无参构造函数");  
   } 
}
 class B extends A
{  
 public B()
  {  
      System.out.println("调用了B的无参构造函数");  
   }    
}

  public class Testeeer
{  
    public static void main(String [] args)
     {  
       B b_01=new B();  
        
      }  
}

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

编译不成功：

 class A
{  
     
}

class B extends A
{  
  
}

  public class Testeeer
{  
    public static void main(String [] args)
     {  
         
       B b_02=new B("你好");  
      }  
} 

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

编译不成功：

 class A
{  
     
}

class B extends A
{  
  public B()
  {  
      System.out.println("调用了B的无参构造函数");  
    } 
 }

  public class Testeeer
{  
    public static void main(String [] args)
     {  
         
       B b_02=new B("你好");  
      }  
}  

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

编译不成功：

 class A
{  
  public A()
  {  
      System.out.println("调用了A的无参构造函数");  
    }    
}

class B extends A
{  
  
 }

  public class Testeeer
{  
    public static void main(String [] args)
     {  
         
       B b_02=new B("你好");  
      }  
}  

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

编译不成功：

 class A
{  
  public A()
  {  
      System.out.println("调用了A的无参构造函数");  
    }    
}

class B extends A
{  
  public B()
  {  
      System.out.println("调用了B的无参构造函数");  
    }  
 }

  public class Testeeer
{  
    public static void main(String [] args)
     {  
         
       B b_02=new B("你好");  
      }  
}  

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

编译成功；

运行结果：

class A
{  
     
 }
 class B extends A
{  
   
   public B(String mess)
   {  
     System.out.println("调用了B的有参构造函数
"+  
         "参数内容为："+mess);  
    }  

}

  public class Testeeer
{  
    public static void main(String [] args)
     {   
       B b_02=new B("你好");  
      }  
}

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

编译失败：

class A
{  
  public A(String mess)
   {  
     System.out.println("调用了A的有参构造函数
"+  
         "参数内容为："+mess);  
    }   
 }
 class B extends A
{  
   
   public B(String mess)
   {  
     System.out.println("调用了B的有参构造函数
"+  
         "参数内容为："+mess);  
    }  

}

  public class Testeeer
{  
    public static void main(String [] args)
     {   
       B b_02=new B("你好");  
      }  
} 

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

编译成功；

运行结果：

class A
{  
  public A(String mess)
   {  
     System.out.println("调用了A的有参构造函数
"+  
         "参数内容为："+mess);  
    }   
 }
 class B extends A
{  
   
   public B(String mess)
   {  
     super(mess);
     System.out.println("调用了B的有参构造函数
"+  
         "参数内容为："+mess);  
    }  

}

  public class Testeeer
{  
    public static void main(String [] args)
     {   
       B b_02=new B("你好");  
      }  
} 

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

编译成功；

运行结果：

class A
{  
  public A(String mess)
   {  
     System.out.println("调用了A的有参构造函数
"+  
         "参数内容为："+mess);  
    } 
   public A()
    {  
      System.out.println("调用了A的无参构造函数");  
     }   
 }
 class B extends A
{  
   
   public B(String mess)
   {  
     
     System.out.println("调用了B的有参构造函数
"+  
         "参数内容为："+mess);  
    }  

}

  public class Testeeer
{  
    public static void main(String [] args)
     {   
       B b_02=new B("你好");  
      }  
} 

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

编译成功；

运行结果：

class A
{  
    
 }
 class B extends A
{  
   
   public B(String mess)
   {  
     
     System.out.println("调用了B的有参构造函数
"+  
         "参数内容为："+mess);  
    }  

}

  public class Testeeer
{  
    public static void main(String [] args)
     {   
       B b_02=new B("你好");  
      }  
}

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（形参）}         运行：超类有参构造，子类有参构造函数