原则：当父类仅有带有参数的构造方法时，子类的构造方法中必须使用super(参数)

super()表示父类的构造方法，子类默认调用父类无参构造方法。

一旦父类仅定义了带参数的构造方法，表示创建父类必须使用带参数构造方法，不接受new父类时不带参数，那么此时子类里默认的调用super()就会报错，不带参数的父类构造方法不存在，必须手动加上含有参数的构造方法。

public class practice {
    public static void main(String[] args) {
        Sun s =new Sun();
        s.show();
    }
}
class Dad{
    public int age;
    Dad(int age)
    {
        this.age = age;
    }
    void show(){
        System.out.println(age);
    }
}
class Sun extends Dad{
    public int age=10;
    public Sun()
    {
        super(35);
    }
}

如果去掉super将会提示错误信息There is no default constructor available in 'basic.Dad'

这个是Java的规定：子类继承父类，子类的构造方法必须调用super()即父类的构造方法，而且必须放在构造方法的第一行。

1、为什么在实例化子类的对象时，会先调用父类的构造器？

答：子类继承父类后，获取到父类的属性和方法，这些属性和方法在使用前必须先初始化，所以须先调用父类的构造器进行初始化

2、在哪里调用父类的构造器？

答：在子类构造器的第一行会隐式的调用 super();，即调用父类的构造器

如果父类中没有定义空参的构造器，则必须在子类的构造器的第一行显示的调用super(参数); ，以调用父类中构造器

如果子类中构造器的第一行写了this();，则就隐式的super();会消失，因为super()和this()都只能在构造器的第一行定义

转载：
Java构造方法之super用法_Java_jcaksonsen的博客-CSDN博客
Java为什么在实例化子类的对象时，会先调用父类的构造器_Java_万万的学习笔记-CSDN博客

1、

隐式调用：子类构造方法没有显示调用父类构造方法（子类中没有super（）），那么父类必须显示提供无参构造方法。



这个时候，系统必须在父类中显示调用无参构造函数。

显示调用：



2、实例1：



在calcPerimeter方法中使用的是length与4相乘，而不是width，是因为width是pirvate类型的，length是protected类型的，private只能在其所在的类中使用。

3、实例2：

super放在第一行



4、实例3：

在new B()的时候，首先要调用父类中无形参构造方法，输出A()，然后才打印B()，在b.f()的时候，因为子类对于父类实现了覆盖，所以输出的是B:f()；
如果父类中无形参或者是有形参的构造方法是private类型的话，是无法通过super调用父类构造方法的（因为super关键字不能访问父类中private的成员变量和方法），也就是说无法new出一个对象来。
如果要产生一个继承对象的话，必须先调用父类非private类型的构造方法，然后再用继承对象的构造方法，之后再new出一个对象来。
先调用父类的构造函数（不管是有形参还是无形参），然后再调用子类的构造函数（不管是有形参还是无形参）
super关键字不能访问父类中private的成员变量和方法。

关键字super在构造方法中的含义：

1、当用子类的构造方法创建一个对象时，子类的构造方法总是先调用父类的某个构造方法；

2、当子类的构造方法没有明确地指明使用父类的哪个构造方法，那么子类就默认调用父类中不带参数的构造方法；

3、需要注意：当某个类中定义了一个或多个构造方法时，那么Java系统就不提供默认的无参数的构造方法了；

如下代码↗：

当子类的构造方法中没有 super() ; 关键字时，系统默认该方法有 super()，此时就调用了父类没有参数的构造方法；

当子类的构造方法中有 super(); 关键字时，系统就调用父类相应参数的构造方法；

//父类
public class superKeyword {
	//父类的成员变量
	int numberFa;
	//无参数构造方法
	superKeyword(){
		System.out.println("系统默认调用了父类无参数构造方法 ");
	} 
	superKeyword(int numberFa){
		this.numberFa = numberFa;
		System.out.println("父类的手机号码： "+numberFa);
	}
}


//父类
public class superKeyword_Test extends superKeyword {
	//成员变量
	int age,number;
	double Fraction;
	
	//没有super();的情况时，系统默认该方法有 super()，此时就调用了父类没有参数的构造方法
	superKeyword_Test(int age,int number){
		this.age = age;
		this.number = number;
		System.out.println("子类的年龄："+age+" 子类的手机号码： "+number+"\n");
	}

	//有super();的情况时，系统就调用父类相应参数的构造方法
	superKeyword_Test(double Fraction, int number) {
		super(117330111);
		this.Fraction = Fraction;
		this.number = number;
		System.out.println("子类的分数："+Fraction+" 子类的手机号码： "+number);
	}
	
   public static void main(String[] args){
	   //调用没有super()的构造方法
	   superKeyword_Test skt = new superKeyword_Test(18,117120);  
           //调用有super()的构造方法
	   superKeyword_Test skt1 = new superKeyword_Test(111.11,117110);     
   }
}


代码输出结果：

系统默认调用了父类无参数构造方法 

子类的年龄：18 子类的手机号码： 117120



父类的手机号码： 117330111

子类的分数：111.11 子类的手机号码： 117110

需要注意的是：

当子类构造方法中没有 super() 关键字，而且父类中没有无参数构造方法，却有一个或多个有参数构造方法时，是错误的；

如下代码↗：

//父类
public class superKeyword {
	//父类的成员变量
	int numberFa;
	superKeyword(int numberFa){
		this.numberFa = numberFa;
		System.out.println("父类的手机号码： "+numberFa);
	}
}


//子类
public class superKeyword_Test extends superKeyword {
	//成员变量
	int age,number;
	double Fraction;
	
	//没有super();的情况时，系统默认该方法有 super()，此时就调用了父类没有参数的构造方法
        //当父类中没有无参数构造方法，却有一个或多个有参数构造方法时，是错误的；
	superKeyword_Test(int age,int number){
		this.age = age;
		this.number = number;
		System.out.println("子类的年龄："+age+" 子类的手机号码： "+number+"\n");
	}

   public static void main(String[] args){
	   //调用没有super()的构造方法
	   superKeyword_Test skt = new superKeyword_Test(18,117120);  
   }
}


代码报错：Implicit super constructor superKeyword() is undefined. Must explicitly invoke another constructor 

                  未定义隐式超级构造函数superKeyword（）。必须显式调用另一个构造函数

 

关键字 super 操作隐藏的成员变量和方法：

1、子类在继承父类的成员变量和方法时，一旦隐藏了父类某个成员变量和方法，那这些成员变量和方法就被分配给关键字 super 所拥有；

2、则子类调用这些被隐藏的成员变量和方法，就需要使用关键字 super 才行；

3、当 super 调用被隐藏的方法时，该方法中出现的成员变量是 被子类隐藏的成员变量 或 继承的成员变量；

如下代码↗：

//父类
public class superKeyword {
    //声明父类的成员变量和方法
	double Fa = 456.456;
	void methodFa(int x,int y){
		Fa = x*y;
		System.out.println("父类的方法，x*y后 Fa的值="+Fa);
	}
}

//父类
public class superKeyword_Test extends superKeyword {
	
	//进行重写，对父类的成员变量和方法进行隐藏
	double Fa = 111.111;
	void methodFa(int x,int y){
		Fa = x+y;
		System.out.println("子类的方法，调用自己的成员变量Fa，x+y后 Fa的值="+Fa);
		//调用父类被隐藏的成员变量
		super.Fa = x-y;
System.out.println("子类的方法，通过super调用被隐藏的成员变量Fa，x-y后 Fa的值="+super.Fa);
	//调用父类被隐藏的方法,此时方法中操作的成员变量是被子类隐藏的成员变量 或 继承的成员变量
		super.methodFa(11, 11);
	}
	
   public static void main(String[] args){
	   //创建对象
	   superKeyword_Test skt = new superKeyword_Test();
	   //调用方法
	   skt.methodFa(100, 10);
   }
}


代码输出结果：

子类的方法，调用自己的成员变量Fa，x+y后 Fa的值=110.0

子类的方法，通过super调用被隐藏的成员变量Fa，x-y后 Fa的值=90.0

父类的方法，x*y后 Fa的值=121.0

需要注意的是：

在类主方法 main() 中是不能进行 super.XXX 操作的；

会报错：Cannot use super in a static context ；  // 不能在静态上下文中使用super