有一个父类有3个构造函数

1. class Fu {
   
2.         public Fu(String s, int i) {
   
3.                         System.out.println("父类2个参数构造函数");
   
4.         }
   
5. 
   
6.         public Fu(String a) {
   
7.                 System.out.println("父类2个参数构造函数");
   
8.         }
   
9. 
   
10.         public Fu() {
    
11.                 System.out.println("父类没参数构造函数");
    
12.         }
    
13. }

复制代码

写一个子类继承父类，并写了2个构造函数

1. public class DuoTaiDemo2 extends Fu {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6.         public static void main(String[] args) {
   
7.                 new DuoTaiDemo2("", 8);
   
8.                 //new DuoTaiDemo2("d");//这行为什么会报错
   
9.                 new DuoTaiDemo2();
   
10. 
    
11.         }
    
12.         public DuoTaiDemo2() {
    
13.                 System.out.println("子类2个参数构造函数");
    
14.         }
    
15.         public DuoTaiDemo2(String s,int i) {
    
16.                 System.out.println("子类2个参数构造函数");
    
17.         }
    
18. }

复制代码

为什么初始化2个子类输出4行结果？
父类没参数构造函数
子类2个参数构造函数
父类没参数构造函数
子类2个参数构造函数

new DuoTaiDemo2("d");//这行为什么会报错?
为什么下面初始化2个子类的输出结果是一样的？
new DuoTaiDemo2("", 8);
new DuoTaiDemo2();

public class DuoTaiDemo2 extends Fu {

        /**
         * @param args
         */
        public static void main(String[] args) {
                new DuoTaiDemo2("", 8);
                //new DuoTaiDemo2("d");//这行为什么会报错 没有这个构造函数 构造函数又不可以继承
                new DuoTaiDemo2();

        }
        public DuoTaiDemo2() {
                super();//默认调用父类空的构造函数
                System.out.println("子类2个参数构造函数");
        }
        public DuoTaiDemo2(String s,int i) {
                super();//默认调用父类空的构造函数
                System.out.println("子类2个参数构造函数");
        }
}

为什么初始化2个子类输出4行结果？
你这个父类里面有空的构造函数  
  public Fu() {

                System.out.println("父类没参数构造函数");

        }

自己去你代码里面找  有空的构造函数
子类的构造函数第一行会自动调用父类空的构造函数

new DuoTaiDemo2("d");//这行为什么会报错?  //没有这个构造函数 构造函数又不可以继承
为什么下面初始化2个子类的输出结果是一样的？ //因为你那两个构造函数都打印的相同的一句话 都是这句话  System.out.println("子类2个参数构造函数");

new DuoTaiDemo2("", 8);
new DuoTaiDemo2();

  public Fu(String s, int i) {
                        System.out.println("父类2个参数构造函数");
        }

        public Fu(String a) {
                System.out.println("父类2个参数构造函数");
        }


只有一个参数的构造函数，你打印输出写错了。。

楼上的你很细心，谢了

1.     class Demo01{
   
2.             int x;
   
3.             String str = "abc";
   
4.             Demo01(){System.out.println("这里是老纸！");}
   
5.             Demo01(int x){
   
6.                     System.out.println("这里是有参数的老纸！");
   
7.             }
   
8.     }
   
9. 
   
10.     class Demo02 extends Demo01{
    
11.             Demo02(){System.out.println("老纸算个叼呀。。。！");}//这里也有默认有一个隐藏的super(),所以下面的有参构造最后依然会调用到父类的无参构造
    
12.             Demo02(int x){
    
13.     //                super();//这里默认有一个隐藏的super();如果你写了this(),那么默认的就没了
    
14.                     this();
    
15.                     System.out.println("你有参数也没用。。。。");
    
16.             }
    
17.     }
    
18. 
    
19.     public class Demo{
    
20.             public static void main(String[] args){
    
21.                     new Demo02();
    
22.                     new Demo02(2);
    
23.             }
    
24.     }

复制代码

构造函数不会继承的，只是子类的构造函数，在执行的时候，默认的会先去调用父类的无参构造函数，所以你主函数里注释掉的那一行，一个参数的构造方法，会出错，因为子类就没对应的构造函数。
而那执行的两句，都会先去执行父类的无参构造，然后执行自己构造里接着的代码，所以输出的结果就是那样的。