有一道题目搞不明白，请指点

Question

public class Cons extends Consup
{    static int c ;
    Cons() 
    {        this(c);
        System.out.println("def");
     }
     Cons(int a) 
     {
            System.out.println("int param");
     }
     private Cons(String a) //为什么要把构造函数设置成private
    // Cons(String a)
     {
             System.out.println("String param");
     }
     public static void main(String[] args) 
     {
            Cons c = new Cons();
            Cons c1 = new Cons("test");//这儿为什么调用了基类的无参构造函数而不是有参数的构造函数？
     }
}
class Consup 
{
        Consup()
         {
             System.out.println("Consup def");
         }
         Consup(String a) 
         {
                  System.out.println("Consup String param");
         }
}
这道题的结果是
Consup def
int param
def
Consup def
String param
为什么不是
Consup def
int param
def
Consup String param
String param

Answer 1

public class Cons extends Consup
{   static int c ;
   Cons()  
  {   this(c);
   System.out.println("def");
   }
   Cons(int a)  
  {
   System.out.println("int param");
   }
   private Cons(String a) //为什么要把构造函数设置成private
为了使此构造方法只能在本类中使用！其实就是private的用法
   // Cons(String a)
   {
super(a);//这样调用的就是父类的有参数的构造方法
   System.out.println("String param");
   }
   public static void main(String[] args)  
  {
   Cons c = new Cons();
   Cons c1 = new Cons("test");//这儿为什么调用了基类的无参构造函数而不是有参数的构造函数？
//因为父类的构造方法是自动调用的，自动调用的就是无参构造方法
   }
}
class Consup  
{
   Consup()
   {
   System.out.println("Consup def");
   }
   Consup(String a)  
  {
   System.out.println("Consup String param");
   }
}
声明：本人新手

Answer 2

public class Cons extends Consup
{  static int c ;
  
  Cons()  
  {
  this(c);
  System.out.println("def");
  }
  
  Cons(int a)  
  {
   System.out.println("int param");
  }
  
  private Cons(String a) //为什么要把构造函数设置成private----不知道有什么意义？？？
  // Cons(String a)
  {
   System.out.println("String param");
  }
  
  public static void main(String[] args)  
  {
  Cons c = new Cons();
  Cons c1 = new Cons("test");//这儿为什么调用了基类的无参构造函数而不是有参数的构造函数？
}                            //1.调用Cons(String a)构造函数，2.这边需要注意，会先隐式调用父类构造函数Consup(), 
                             //3.执行父类的无参构造函数，执行输出语句，输出"Consup def"，
                             //4.回到Cons(String a)构造函数，执行输出语句，输出"String param"
}class Consup  
{
  Consup()
  {
   System.out.println("Consup def");
  }
  
  Consup(String a)  
  {
   System.out.println("Consup String param");
  }
}

Answer 3

我一直以为java里面跟c++一样呢，new子类的时候先调用基类相应的构造函数呢。

Answer 4

new对象时先调用基类的无参构造方法,输出Consup def
然后回到本类的无参构造方法Cons(),通过this关键字，找到本类的有参构造方法，输出int param
继续回到Cons()，输出def
new c1时同样先调用直接基类的无参构造方法（因为有参方法被子类覆盖），然后回到子类的有参构造方法。
子类中如果有super关键字，可以通过它来访问基类中被子类覆盖的方法或属性。
声明：本人也是菜鸟。