今天在空参数这里再次迷糊了，在继承里面的构造方法这里
class Father
  {
        Father(){}
         Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }
  class Son extends Father
  {
   Son()
   {
      System.out.println("son");
   }
   Son(int age)
   {
    super(age);
    System.out.println("son age:"+age);
   }
  }
  Son s = new Son();  
  Son s = new Son(2);
那个大哥帮忙解决下空参数函数的理解，最后好能有应用的列子

class Father
  {
        Father(){}
         Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }
  class Son extends Father
  {
   Son()
   {
      System.out.println("son");
   }
   Son(int age)
   {
    super(age);
    System.out.println("son age:"+age);
   }
  }
  Son s = new Son();  // new一个无参数的Son对象，java虚拟机会先调用Son父类的无参数构造函数，调用完父类的构造函数在调用自身的构造函数
  Son s = new Son(2);  // new一个有参数的Son对象，java虚拟机会先调用Son父类的有参数构造函数，调用完父类的构造函数在调用自身的构造函数
当new一个对象时，不管new出的是有参数或无参数构造函数，都会先调用父类的有参数或无参数构造函数，调用完父类的构造函数在调用自身的构造函数

子类每一个构造函数内的第一行都有一句隐式super()；
class Father
  {
        Father(){}
         Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }
  class Son extends Father
  {
   Son()
   {
      //这里隐含会有一句代码 super()，来访问Father的空参数构造方法也就是Father(){}
      System.out.println("son");
   }
   Son(int age)
   {
     //这里你手动的加了一个super(age),来 访问Father的有参的构造方法，也就是Father(int age){......}
    super(age);
    System.out.println("son age:"+age);
   }
  }
  Son s = new Son();  
  Son s = new Son(2);

子类每一个构造函数内的第一行都有一句隐式super()；
class Father
  {
        Father(){}
         Fahter(int age)
   {
    System.out.println("father age:"+age);
   }
  }
  class Son extends Father
  {
   Son()
   {
      //这里隐含会有一句代码 super()，来访问Father的空参数构造方法也就是Father(){}
      System.out.println("son");
   }
   Son(int age)
   {
     //这里你手动的加了一个super(age),来 访问Father的有参的构造方法，也就是Father(int age){......},这时这里就不会又默认的super()了
    super(age);
    System.out.println("son age:"+age);
   }
  }
  Son s = new Son();  
  Son s = new Son(2);

class Person {

                  Person(){}
          Person(int age)
                        {
                                System.out.println("Person age:"+age);
                        }
  
                        }
   //子类 会继承父类的构造函数，属性和方法等等
   class Son extends Person
   {
                Son()
                {
                   System.out.println("son");
                }
                Son(int age)
                {
                 super(age);   //super关键字是代表父类的意思，可以看成Person(2)，这样肯定就不难看出是调用父类的那个有参构造方法了。因为参数是主函数中的那个s1对象传进来的参数,即:2
                 System.out.println("son age:"+age);
                }
   }
  

                       
class Test {
         public static void main(String[] args) {
                Son s = new Son();       //创建了子类的对象s，因为是创建了一个无参的构造方法，这时，它会重写父类的构造方法。  
                                                                       
                                        /*
                                        打印结果为:  son.   
                                        因为重写了父类无参构造的方法
                                        */

                                 Son s1 = new Son(2);      //这个方法和上面的类同，只不过是创建了有参的构造方法，并重写了父类的构造方法。
                                 /*
                                 打印结果为：
                                 Person age: 2                    //因为子类里引用了super关键字，就会调用父类的相应方法。
                                 son age: 2                       //因为重写了父类的有参构造方法。
                                 */
                 }

}

/*
昨天晚上，夜深人静~.
*/

//定义父类
class FatherClass{
        String name = "Mary";
        String color = "red";
        
        FatherClass(){
                System.out.println("调用父类不含参数的构造方法~~！");               
        }
        FatherClass(String name, String color){
                this.name = name;
                this.color = color;
                System.out.println("调用父类含有参数的构造方法*-*！父父父有有有");        
        }
}

// 毫无疑问的是：构造方法是无法继承的，因为他们的类名不同。
// 一：若子类中没有构造方法，java编译器为子类添加空的构造方法，构造方法第一行为super();
/*class SonClass extends FatherClass{
}

public class Extension {
        public static void main(String[] args){
                SonClass s = new SonClass();     //为子类添加无参数的构造方法。
                System.out.println(s.name +"---***---"+ s.color);
        }
}*/

/*Console:
调用父类不含参数的构造方法~~！
Mary---***---red */        

// 二：若子类添加了任意类型的构造方法，java编译器不会为子类无参数的构造方法。
/*class SonClass extends FatherClass{
        SonClass(String name, String color){
                super(name, color);
        }
}

public class Extension {
        public static void main(String[] args){
                SonClass s = new SonClass();     //没有为子类添加无参数的构造方法。
                System.out.println(s.name +"---***---"+ s.color);
        }
}*/

/*Error:
        Exception in thread "main" java.lang.Error: Unresolved compilation problem:
                The constructor SonClass() is undefined

                at Extension.main(Extension.java:43)*/
//错误提示：子类无参数的构造方法没有被定义。

// 三 、若子类的构造方法没有加super语句，java编译器会为该构造方法加一个无参数的super语句，即super();
class SonClass extends FatherClass{
        SonClass(String name, String color){
                System.out.println("调用子含有参数的构造方法*-*！子子子有有有");
        }
}

public class Extension {
        public static void main(String[] args){
                SonClass s = new SonClass("John", "Golden");   //实际上调用了父类无参数的构造方法，参数没有得到传递。
                System.out.println(s.name +"---***---"+ s.color);
        }
}

/*Console:
调用父类不含参数的构造方法~~！
调用子含有参数的构造方法*-*！子子子有有有
Mary---***---red*/