class My {
        public static void main(String[] args) {
                Father father = new Father("tom");
                Son son = new Son();
                father.show();
                son.print();

        }
}

class Father {
        String name;

        Father(String name) {
                this.name = name;

                System.out.println("father 构造");
        }

        public void show() {

                System.out.println("father");
        }

}

class Son extends Father {
        String name = "tom1";

        Son() {                           //这里为什么会报错呢 感觉没错误啊
                System.out.println("son 构造");
        }

        public void print() {

                System.out.println("son");
        }
}
求大神解释

哈哈哈哈

1. class My {
   
2.         public static void main(String[] args) {
   
3.                 Father father = new Father("tom");
   
4.                 Son son = new Son("tom1");
   
5.                 father.show();
   
6.                 son.print();
   
7. 
   
8.         }
   
9. }
   
10. 
    
11. class Father {
    
12.         private String name;
    
13. 
    
14.         Father(String name) {
    
15.                 this.name = name;
    
16. 
    
17.                 System.out.println("father 构造");
    
18.         }
    
19. 
    
20.         public void show() {
    
21. 
    
22.                 System.out.println("father");
    
23.         }
    
24. 
    
25. }
    
26. 
    
27. class Son extends Father {
    
28. 
    
29.         Son(String name) {
    
30.                 super(name);
    
31.                 // TODO Auto-generated constructor stub
    
32.         }
    
33. 
    
34.         public void show() { // 这里为什么会报错呢 感觉没错误啊
    
35.                 System.out.println("son 构造");
    
36.         }
    
37. 
    
38.         public void print() {
    
39. 
    
40.                 System.out.println("son");
    
41.         }
    
42. }

复制代码

你写了 Father(String name)那么 Father(){}这个空参构造函数就没有了,想建立子类对象,父类中必须有对应的构造函数.所以一般编程的时候,定义了带参数的构造函数的时候,一般都再手动写一个空参的添在前面.用起来方便.

子类在构造本类对象的时候，实际上是先在子类对象内部构造了一个父类对象（所以才会拥有父类的成员），因此，子类在构造的过程中一定要先调用父类的构造方法。可以显式地指明调用父类中的某个构造方法，也可以不写，但默认调用父类的空构造方法。 如果父类中有了用户自定义的构造方法，则系统就不会再默认的在父类中加一个空构造方法。因此，当你编译的时候，子类构造方法找不到父类的空构造方法，就会报错。
解决办法：1、在父类中手动定义一个空构造方法；2、也可以在子类构造方法中显示地调用父类中存在的构造方法。比如Father(String name)

子类所有的构造函数，默认都会访问父类中空参数的构造函数。
因为子类每一个构造函数内部的第一行都有一句隐式super()
当父类中没有空参数的构造函数时，子类必须手动通过super或this语句来指定
要访问的构造函数。
当然，子类构造函数第一行也可以手动指定this语句来访问本类中的构造函数。
子类中至少会有一个构造函数会访问父类中的构造函数。
class Test10 {
        public static void main(String[] args) {
                Father father = new Father("tom");
                Son son = new Son();
                father.show();
                son.print();

        }
}

class Father {
        String name;

        Father(String name) {
                this.name = name;

                System.out.println("father 构造");
        }

        public void show() {

                System.out.println("father");
        }

}

class Son extends Father {
        String name = "tom1";

        Son() {
                                super("lisi");                          //这里为什么会报错呢 感觉没错误啊
                System.out.println("son 构造");
        }

        public void print() {

                System.out.println("son");
        }
}

正确代码解释如下：
class My {
    public static void main(String[] args) {
            Father father = new Father("tom");
            Son son = new Son();
            father.show();
            son.print();
    }
}
class Father {
    String name;
    Father() {}
    Father(String name) {
            this.name = name;
            System.out.println("father 构造");
    }
    public void show() {
            System.out.println("father");
    }
}
class Son extends Father {
    String name = "tom1";
    Son(){
     //因为这里有一个默认的super()调用父类的无参构造函数，而你的父类没有，所以报错
        //或手动写上调用父类有参构造方法 super("..");错误就会消失
     System.out.println("son 构造");
    }
    public void print() {
            System.out.println("son");
    }
}