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的有参构造函数\n"+
          "参数内容为："+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的有参构造函数\n"+
          "参数内容为："+mess);
     }
  }
  class B extends A
 {  

    public B(String mess)
    {
      System.out.println("调用了B的有参构造函数\n"+
          "参数内容为："+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的有参构造函数\n"+
          "参数内容为："+mess);
     }
  }
  class B extends A
 {  

    public B(String mess)
    {
      super(mess);
      System.out.println("调用了B的有参构造函数\n"+
          "参数内容为："+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的有参构造函数\n"+
          "参数内容为："+mess);
     }
    public A()
     {
       System.out.println("调用了A的无参构造函数");
      }
  }
  class B extends A
 {  

    public B(String mess)
    {  

      System.out.println("调用了B的有参构造函数\n"+
          "参数内容为："+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的有参构造函数\n"+
          "参数内容为："+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（形参）}         运行：超类有参构造，子类有参构造函数