Java Language
super mot clé
Recherche…
Super mot-clé avec des exemples
super mot-clé joue un rôle important dans trois endroits
- Niveau constructeur
- Niveau de méthode
- Niveau variable
Niveau constructeur
super
mot clé super
est utilisé pour appeler le constructeur de la classe parent. Ce constructeur peut être constructeur par défaut ou constructeur paramétré.
Constructeur par défaut:
super();
Constructeur paramétré:
super(int no, double amount, String name);
class Parentclass { Parentclass(){ System.out.println("Constructor of Superclass"); } } class Subclass extends Parentclass { Subclass(){ /* Compile adds super() here at the first line * of this constructor implicitly */ System.out.println("Constructor of Subclass"); } Subclass(int n1){ /* Compile adds super() here at the first line * of this constructor implicitly */ System.out.println("Constructor with arg"); } void display(){ System.out.println("Hello"); } public static void main(String args[]){ // Creating object using default constructor Subclass obj= new Subclass(); //Calling sub class method obj.display(); //Creating object 2 using arg constructor Subclass obj2= new Subclass(10); obj2.display(); } }
Note : super()
doit être la première instruction du constructeur sinon nous obtiendrons le message d'erreur de compilation.
Niveau de méthode
super
mot super
clé peut également être utilisé en cas de substitution de méthode. super
mot clé super
peut être utilisé pour appeler ou appeler la méthode de la classe parente.
class Parentclass
{
//Overridden method
void display(){
System.out.println("Parent class method");
}
}
class Subclass extends Parentclass
{
//Overriding method
void display(){
System.out.println("Child class method");
}
void printMsg(){
//This would call Overriding method
display();
//This would call Overridden method
super.display();
}
public static void main(String args[]){
Subclass obj= new Subclass();
obj.printMsg();
}
}
Remarque : S'il n'y a pas de substitution de méthode, il n'est pas nécessaire d'utiliser le mot super
clé super
pour appeler la méthode de la classe parente.
Niveau variable
super
est utilisé pour désigner la variable d'instance de la classe parente immédiate. En cas d'héritage, la classe de base et la classe dérivée peuvent avoir des membres de données similaires. Afin de différencier le membre de données de la classe de base / parent et de la classe dérivée / enfant, dans le contexte de la classe dérivée les membres doivent être précédés du mot super
clé 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();
}
}
Remarque : Si vous n'écrivez pas de mot super
clé super
avant le nom du membre de données de la classe de base, il sera alors appelé membre de données de classe en cours et le membre de données de classe de base est masqué dans le contexte de la classe dérivée.