“子类中至少会有一个构造函数会访问父类中的构造函数”这句话怎么理解？？？

当你不给子类写特定的构造函数的时候，子类会默认调用父类的构造函数

{:soso_e126:}我刚才打了好几百字的内容怎么木有了！！！！！！！{:soso_e115:}

在JAVA中，我们通常把函数叫做方法。对于子类调用父类的构造方法可以做出如下解释： 子类无条件地继承父类的不含参数的构造方法。如果子类自己没有构造方法，则它将继承父类的无参数构造方法作为自己的构造方法；如果子类自己定义了构造方法，则在创建新对象时，它将先执行继承自父类的无参数构造方法，然后再执行自己的构造方法。对于父类含参数的构造方法，子类可以通过在自己的构造方法中使用 super 关键字来调用它，但这个调用语句必须是子类构造方法的第一个可执行语句。

比如你定义
class father{}

class son entends father{
}
每个类都有一个默认的构造函数.son类没有写构造函数,就有个默认构造函数.
假如子类 son定义了 son(){}.   那么在这个构造函数内,就会自动添加进super();就是父类的默认构造函数.

子类中至少会有一个构造函数会访问父类中的构造函数，也就是说父类的初始化优先与子类调用，这是因为子类在继承父类时子类要知道父类对其属性的初始化方式。因此，假设自己定义的任何一个没有构造函数的类，该类初始化时，会在子类中的构造函数的第一行默认通过super()语句调用object的构造函数，但是由于有构造函数重载的存在，对于有多个构造函数的子类，有些构造函数可以在第一行同过this()关键字调用该类的其它构造函数，这时这些构造函数就可以说是没有访问父类中的构造函数，或者说是没有直接访问父类的构造函数。这是我的理解，希望对你有帮助。

子类的构造函数中默认有个super()方法

这是因为，子类在不定义构造函数的时候，默认都会有一个无参数的构造函数，而构造函数的第一句，有个隐式语句，super()，会调用父类中的构造函数，对子类进行初始化。所以，子类至少有一个构造函数会访问父类的构造函数。
如：
class Fu{
}
class Zi extends Fu{
   /*
      Zi(){
          //super();隐式语句
       }
    此处注释代表默认的构造函数
   */
}

其实你可以看我写的代码，运行一下看看，就知道怎么回事了，子类的构造函数可以调用自己其他的构造函数，父类也是如此，子类的不同构造函数可以调用父类的不同构造函数，不一定子类child()就一定是super（），可以是调用父类有参数的构造函数，总之在每次实例化时，子类调用父类的构造函数只能调用一次，不能出现多次调用。

1. package heima.shiba;
   
2. 
   
3. public class ExtendsDemo {
   
4. 
   
5.         public static void main(String[] args) {
   
6.                 child c = new child("小明");
   
7.                 child c1 = new child();
   
8.                 father f = new father("大明");
   
9.                 father f1 = new father();
   
10.         }
    
11. 
    
12. }
    
13. class father {
    
14.         public father(){
    
15.                 System.out.println("father constructor()");
    
16.         }
    
17.         public father(String name){
    
18.                 this();
    
19.                 System.out.println("father constructor(String name)"+name);
    
20.         }
    
21. }
    
22. class child extends father{
    
23.         public child(){
    
24.                 super("大明");
    
25.                 System.out.println("child constructor()");
    
26.         }
    
27.         public child(String name){
    
28.                 this();
    
29.                 System.out.println("child constructor(String name)"+name);
    
30.         }
    
31. }

复制代码

注意：this和super不能同时出现在一个构造函数内，还有不能出现自己调用自己的情况，如果尝试编译器会提示出现循环调用，无法正常编译，
打印结果如下：
//child c = new child("小明");
father constructor()
father constructor(String name)大明
child constructor()
child constructor(String name)小明
//child c1 = new child();
father constructor()
father constructor(String name)大明
child constructor()
//father f = new father("大明");
father constructor()
father constructor(String name)大明
//father f = new father();
father constructor()
如果代码改成这样，

1. class child extends father{
   
2.         public child(){
   
3.                 super("大明");
   
4.                 System.out.println("child constructor()");
   
5.         }
   
6.         public child(String name){
   
7.                 super();
   
8.                 System.out.println("child constructor(String name)"+name);
   
9.         }
   
10. }

复制代码

结果就是这样了：
father constructor()
child constructor(String name)小明
father constructor()
father constructor(String name)大明
child constructor()
father constructor()
father constructor(String name)大明
father constructor()
是不是明白了，希望能帮到你，实际没有什么实用性，只是纯粹研究罢了

子类构造函数内不出现this调用本类其他构造函数时，默认有super（）来调用父类构造函数。