super 关键字在三个地方起着重要作用

• 构造函数级别
• 方法级别
• 变量级别

构造函数级别的super关键字

Super关键字用于调用父类构造函数。
此构造函数可以是默认构造函数或者参数化构造函数。

• 默认构造函数：super();
• 参数化构造函数：super(int no, double amount, String name);

class Parentclass
{
    Parentclass(){
        System.out.println("Constructor of Superclass");
    }
}
class Subclass extends Parentclass
{
    Subclass(){
    /* 
    * 编译器将super()隐式添加到此构造函数的第一行
    */
    System.out.println("Constructor of Subclass");
    }
    Subclass(int n1){
    /* 
    * 编译器将super()隐式添加到此构造函数的第一行
    */
    System.out.println("Constructor with arg");
    }
    void display(){
        System.out.println("Hello");
    }
    public static void main(String args[]){
    //使用默认构造函数创建对象
    Subclass obj= new Subclass();
    //调用子类方法
    obj.display();
    //使用arg构造函数创建对象2
    Subclass obj2= new Subclass(10);
    obj2.display();
    }
}

注意：Super()必须是构造函数中的第一个语句，否则我们将获得编译错误消息。

方法级别的super关键字

在方法重写的情况下也可以使用super关键字。super关键字可用于调用父类方法。

class Parentclass
{
     //被重写的方法
     void display(){
     System.out.println("Parent class method");
     }
}
class Subclass extends Parentclass
{
     //重写的方法
     void display(){
     System.out.println("Child class method");
     }
     void printMsg(){
          //调用重写的方法
          display();
          //调用被重写的方法
          super.display();
    }
    public static void main(String args[]){
    Subclass obj= new Subclass();
    obj.printMsg();
    }
}

注意：如果没有方法被重写，那么我们不需要使用Super关键字来调用父类方法。

变量级别的super关键字

Super用于将立即引用父类实例变量。
在继承的情况下，可能存在基类和派生类可以具有类似的数据成员。
在派生类的上下文中，在基本/父类和派生/子类之间的数据成员之间进行区分，在派生类数据的上下文中。
成员前面必须有Super关键字。

//Parent class or Superclass
class Parentclass
{
int num=100;
}
//Child class or subclass
class Subclass extends Parentclass
{
/* I am declaring the same variable
num in child class too.
/
int num=110;
void printNumber(){
System.out.println(num); //It will print value 110
System.out.println(super.num); //It will print value 100
}
public static void main(String args[]){
Subclass obj= new Subclass();
obj.printNumber();
}
}

注意：如果我们在基类数据成员名称之前没有super关键字，那么它将被称为当前类数据成员，基类数据成员隐藏在派生类的上下文中。