Java super
Java super
In deze tutorial leren we over het super trefwoord in Java met behulp van voorbeelden.
De super trefwoord in Java wordt gebruikt in subklassen om toegang te krijgen tot leden van superklassen (attributen, constructors en methoden).
Voordat we meer te weten komen over de super zoekwoord, zorg ervoor dat u op de hoogte bent van Java-overerving.
Gebruik van superzoekwoord
- Om methoden aan te roepen van de superklasse die wordt overschreven in de subklasse.
- Om toegang te krijgen tot attributen (velden) van de superklasse als zowel de superklasse als de subklasse attributen met dezelfde naam hebben.
- Om de superklasse no-arg (standaard) of geparametriseerde constructor expliciet aan te roepen vanuit de subklasse-constructor.
Laten we elk van deze toepassingen begrijpen.
1. Toegang tot overschreven methoden van de superklasse
Als methoden met dezelfde naam zijn gedefinieerd in zowel de superklasse als de subklasse, overschrijft de methode in de subklasse de methode in de superklasse. Dit wordt methode overschrijven genoemd.
Voorbeeld 1:Methode overschrijven
class Animal {
// overridden method
public void display(){
System.out.println("I am an animal");
}
}
class Dog extends Animal {
// overriding method
@Override
public void display(){
System.out.println("I am a dog");
}
public void printMessage(){
display();
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.printMessage();
}
}
Uitvoer
I am a dog
In dit voorbeeld, door een object dog1 . te maken van Hond klasse, kunnen we zijn methode printMessage() . noemen die vervolgens de display() . uitvoert verklaring.
Sinds display() is gedefinieerd in beide klassen, de methode van subklasse Hond overschrijft de methode van superklasse Animal . Vandaar dat de display() van de subklasse wordt aangeroepen.
Wat als de overschreven methode van de superklasse moet worden aangeroepen?
We gebruiken super.display() als de overschreven methode display() van superklasse Dier moet worden gebeld.
Voorbeeld 2:super to Call Superclass Method
class Animal {
// overridden method
public void display(){
System.out.println("I am an animal");
}
}
class Dog extends Animal {
// overriding method
@Override
public void display(){
System.out.println("I am a dog");
}
public void printMessage(){
// this calls overriding method
display();
// this calls overridden method
super.display();
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.printMessage();
}
}
Uitvoer
I am a dog I am an animal
Hier, hoe het bovenstaande programma werkt.
2. Toegangsattributen van de Superklasse
De superklasse en subklasse kunnen attributen met dezelfde naam hebben. We gebruiken de super trefwoord om toegang te krijgen tot het attribuut van de superklasse.
Voorbeeld 3:Toegang tot superklassekenmerk
class Animal {
protected String type="animal";
}
class Dog extends Animal {
public String type="mammal";
public void printType() {
System.out.println("I am a " + type);
System.out.println("I am an " + super.type);
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
dog1.printType();
}
}
Uitvoer :
I am a mammal I am an animal
In dit voorbeeld hebben we hetzelfde instantieveld type . gedefinieerd in zowel de superklasse Animal en de subklasse Hond .
We hebben toen een object gemaakt dog1 van de Hond klas. Dan, de printType() methode wordt aangeroepen met dit object.
Binnen de printType() functie,
- type verwijst naar het attribuut van de subklasse Hond .
- super.type verwijst naar het attribuut van de superklasse Animal.
Vandaar, System.out.println("I am a " + type); prints
Ik ben een zoogdier
. En, System.out.println("I am an " + super.type); prints
Ik ben een dier
.
3. Gebruik van super() om toegang te krijgen tot de superklasse-constructor
Zoals we weten, wordt de standaardconstructor automatisch aangeroepen wanneer een object van een klasse wordt gemaakt.
Om de constructor van de superklasse expliciet aan te roepen vanuit de constructor van de subklasse, gebruiken we super() . Het is een speciale vorm van de super zoekwoord.
super() kan alleen worden gebruikt binnen de subklasse-constructor en moet de eerste instructie zijn.
Voorbeeld 4:Gebruik van super()
class Animal {
// default or no-arg constructor of class Animal
Animal() {
System.out.println("I am an animal");
}
}
class Dog extends Animal {
// default or no-arg constructor of class Dog
Dog() {
// calling default constructor of the superclass
super();
System.out.println("I am a dog");
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
}
}
Uitvoer
I am an animal I am a dog
Hier, wanneer een object dog1 van Hond class is gemaakt, roept het automatisch de standaard of no-arg constructor van die klasse aan.
Binnen de subklasse-constructor, de super() statement roept de constructor van de superklasse aan en voert de instructies erin uit. Daarom krijgen we de output
Ik ben een dier
.
De stroom van het programma keert dan terug naar de constructor van de subklasse en voert de resterende instructies uit. Dus Ik ben een hond wordt afgedrukt.
Echter, met behulp van super() is niet verplicht. Zelfs als super() niet wordt gebruikt in de subklasse-constructor, roept de compiler impliciet de standaardconstructor van de superklasse aan.
Dus, waarom zou je redundante code gebruiken als de compiler automatisch super() aanroept?
Het is vereist als de geparametriseerde constructor (een constructor die argumenten nodig heeft) van de superklasse moet worden aangeroepen vanuit de subklasse-constructor.
De geparametreerde super() moet altijd de eerste instructie zijn in de hoofdtekst van de constructor van de subklasse, anders krijgen we een compilatiefout.
Voorbeeld 5:roep een geparametriseerde constructor aan met super()
class Animal {
// default or no-arg constructor
Animal() {
System.out.println("I am an animal");
}
// parameterized constructor
Animal(String type) {
System.out.println("Type: "+type);
}
}
class Dog extends Animal {
// default constructor
Dog() {
// calling parameterized constructor of the superclass
super("Animal");
System.out.println("I am a dog");
}
}
class Main {
public static void main(String[] args) {
Dog dog1 = new Dog();
}
}
Uitvoer
Type: Animal I am a dog
De compiler kan automatisch de no-arg-constructor aanroepen. Het kan echter geen geparametriseerde constructors aanroepen.
Als een constructor met parameters moet worden aangeroepen, moeten we deze expliciet definiëren in de constructor van de subklasse.
Merk op dat we in het bovenstaande voorbeeld expliciet de geparametriseerde constructor super("Animal") . hebben genoemd . De compiler roept in dit geval niet de standaardconstructor van de superklasse aan.
Java