Java @override: Methode overschrijven en Runtime-polymorfisme

java override method overriding

In deze tutorial wordt uitgelegd hoe u Runtime Polymorphism in Java bereikt met behulp van Method Overriding en @override annotation met eenvoudige voorbeelden:

We hebben het polymorfisme-concept en Compile-time polymorfisme al in detail besproken. In deze tutorial gaan we verder met Runtime-polymorfisme in Java.

In tegenstelling tot het polymorfisme tijdens het compileren, waarbij de methodeaanroep tijdens het compileren wordt opgelost, wordt de methodeaanroep in runtime-polymorfisme tijdens de uitvoering opgelost.

​ Bekijk hier ALLE Java-tutorials.

Wat je leert:

• Runtime-polymorfisme in Java
  • Bereik Runtime Polymorphism in Java - Method Overriding
  • Upcasting
  • Voordelen van dynamisch / runtime-polymorfisme
  • Virtuele functie / methode in Java
• @override annotatie in Java
• Overbelasting en overschrijven in Java
  • Overbelasting versus overschrijven in Java
  • Veel Gestelde Vragen
• Gevolgtrekking
  • Aanbevolen literatuur

Runtime-polymorfisme in Java

Een runtime-polymorfisme dat ook bekend staat als dynamisch polymorfisme of Dynamische methode verzending is een techniek waarbij een overschreven methodeaanroep dynamisch wordt opgelost tijdens runtime.

Runtime-polymorfisme in Java wordt bereikt door ' methode overschrijven ​Methode overschrijven is een techniek waarmee een methode in de bovenliggende klasse opnieuw wordt gedefinieerd of overschreven in de onderliggende klasse.

Wanneer de methode in een klasse wordt overschreven, lost de dispatch-techniek van de dynamische methode de aanroep van de overschreven methode tijdens runtime op en niet tijdens het compileren.

Bereik Runtime Polymorphism in Java - Method Overriding

Methode overschrijven is de benadering die we gebruiken om runtime polymorfisme in Java te bereiken. Zoals eerder vermeld, is het overschrijven van een methode een techniek waarbij een subklasse een methode toevoegt die al aanwezig is in de bovenliggende klasse en nieuwe functionaliteit aan deze methode toevoegt. Vervolgens zeggen we dat de basisklasse-methode wordt overschreven.

De nieuwe methode die we in de subklasse hebben gedefinieerd met hetzelfde prototype als de methode van de bovenliggende klasse, maar met een andere implementatie, wordt de ' overheersende methode ' ​De methode in de bovenliggende klasse staat bekend als de ' Overschreven methode ​

beste websites om anime gratis te bekijken

Als de methode eenmaal is overschreven, blijft de vraag hoe de aanroep naar deze overschreven methode wordt opgelost.

We noemen de overschreven methode meestal via de referentie van de basisklasse. We zullen een referentie van het type base maken en vervolgens een kindklasse-object toewijzen met behulp van het nieuwe trefwoord.

Het hangt dus af van de inhoud van de referentievariabele of naar welk object wordt verwezen door de referentie van de basisklasse, dat bepaalt welke methode moet worden aangeroepen. Dus als de referentieobjecten naar het object van de onderliggende klasse verwijzen, wordt de overriding-methode aangeroepen.

Anders, als het referentieobject een basisklasseobject bevat, wordt de overschreven methode aangeroepen. Een onderwerp dat we duidelijk moeten zijn in runtime polymorfisme, vooral voor dynamische verzending van methoden, is 'Upcasting', dat hieronder wordt uitgelegd.

Upcasting

Wanneer een referentieobject van de bovenliggende klasse die we hierboven hebben besproken, verwijst naar of verwijst naar het object van de subklasse, dan noemen we dat Upcasting.

Laten we upcasting aan de hand van een eenvoudig voorbeeld bekijken.

Bedenk dat we een klasse ‘BaseClass’ hebben en we breiden deze BaseClass uit om een ​​nieuwe klasse DerivedClass te creëren. Deze structuur ziet er uit zoals hieronder weergegeven.

Om upcasting te implementeren, zullen we een referentievariabele van het type BaseClass declareren. Vervolgens wijzen we een object van DerivedClass toe aan de referentie van de klasse BaseClass zoals gedaan in de onderstaande code-instructie.

Dus hier kunnen we zeggen dat we het DerivedClass-object hebben upcast naar BaseClass. Wat betreft runtime polymorfisme is het concept van upcasting erg belangrijk.

Dus in het algemeen is upcasting het proces waarbij onderliggende of subklasse-objecten worden toegewezen aan de referentie van een ouder of superklasse.

Het onderstaande Java-programma demonstreert het overschrijven van methoden en laat ook zien hoe upcasting wordt uitgevoerd om overschreven methodeaanroepen tijdens runtime op te lossen.

Uitgang:

In het bovenstaande programma hebben we twee klassen, namelijk child1 en child2, die beide zijn afgeleid van een ‘Parent’ class. Bovenliggende klas heeft een methode ‘Afdrukken’ die wordt overschreven in zowel de klassen kind1 als kind2. Vervolgens maken we in de hoofdmethode een referentieobject van de bovenliggende klasse met de naam ‘parent’.

We wijzen het eerst een object van de klasse Parent toe en roepen vervolgens de methode 'Print ()' aan. Vervolgens herhalen we dit door eerst het child1-object en vervolgens het child2-object toe te wijzen aan de Parent reference.

hoe je een null-pointer-uitzondering in java kunt vermijden

De uitvoer wordt weergegeven, afhankelijk van de inhoud van de bovenliggende referentie, en de juiste afdrukmethode wordt aangeroepen.

Voordelen van dynamisch / runtime-polymorfisme

• Met dynamisch polymorfisme mag de programmeur methoden overschrijven.
• Het stelt klassen in staat om een ​​methode met algemene implementatie te definiëren die de afgeleiden ervan vervolgens kunnen overschrijven en de specifieke implementatie kunnen bieden.
• Met dynamische methode-verzending wordt de methodeaanroep tijdens runtime opgelost, in tegenstelling tot overbelasting die tijdens het compileren wordt beslist. Dit zorgt voor meer flexibiliteit voor de programmeurs.

Omdat runtime-polymorfisme de juiste methode tijdens runtime aan de aanroep bindt en we het ook wel noemen dynamische binding of late binding ​Compile-time polymorfisme ondersteunt daarentegen statische binding of vroege binding ​

Statische versus dynamische binding

Virtuele functie / methode in Java

Virtuele functie of methode in Java is een functie die wordt gebruikt met Runtime-polymorfisme. In tegenstelling tot C ++, Java heeft geen speciaal ‘virtueel’ zoekwoord om aan te geven dat een methode virtueel is. Een methode die is gedefinieerd in de basisklasse en overschreven in de afgeleide klasse, is virtueel.

In Java is standaard elke niet-statische methode, behalve privé en definitief, een virtuele functie. Merk dus op dat de methoden die we hierboven hebben besproken die overschrijven om runtime-polymorfisme te implementeren, ook virtuele methoden zijn.

Aangezien de statische methode is gebonden aan Klasse en niet kan worden aangeroepen met een object, kan deze niet worden gebruikt met runtime-polymorfisme en is het ook geen virtuele functie.

Interfaces in Java zijn standaard virtueel. Klassen die interfaces implementeren, bieden implementaties voor de interfacemethoden. Net als bij runtime-polymorfisme, worden call-to-interface-methoden ook tijdens runtime opgelost.

Onthoud dat aangezien methoden in een interface zijn ontworpen om te worden overschreven, alle interfacemethoden virtuele functies zijn.

Beschouw bijvoorbeeld de volgende code:

In de bovenstaande code is de methode accelerate () een virtuele functie aangezien deze deel uitmaakt van de interface-auto en is ontworpen om te worden overschreven.

@override annotatie in Java

De annotatie @override is de standaardannotatie in Java. Deze annotatie is geïntroduceerd in Java 1.5. De annotatie @override wordt gebruikt wanneer de subklassemethode de superklassemethode overschrijft.

Door Java @override annotatie te gebruiken om aan te geven dat de methode de bovenliggende klassemethode overschrijft, geeft een compiler een waarschuwing af als de geannoteerde methode niet wordt overschreven. Maakt het dus verplicht dat de methode wordt overschreven wanneer de @override-annotatie wordt gebruikt.

Ten tweede maken we de code beter leesbaar door de annotatie @override te gebruiken. We kunnen ons meteen realiseren dat de methode die wordt gedeclareerd, moet worden overschreven.

De algemene syntaxis van de annotatie Java @override is

Het onderstaande Java-programma toont het gebruik van @override-annotatie.

Uitgang:

In het bovenstaande programma hebben we een BaseClass die een weergavemethode definieert. Vervolgens leiden we een klasse DerivedClass af van deze BaseClass en markeren we de weergavemethode met de @override-annotatie. Deze methode wordt overschreven in de DerivedClass.

In de hoofdmethode maken we een BaseClass-objectreferentie en verwijzen deze naar het DerivedClass-object waardoor de referentie de DerivedClass-weergavemethode aanroept.

Als we de methode display () niet hadden geïmplementeerd in de klasse Derived, dan zou de compiler een compilerwaarschuwing hebben gegeven omdat deze is gemarkeerd met @override-annotatie.

Overbelasting en overschrijven in Java

Nu we zowel overbelasting als overbelasting in Java hebben besproken, laten we deze twee concepten samenvatten.

Overbelasting is gerelateerd aan compilatietijd polymorfisme, d.w.z. we implementeren compilatietijd polymorfisme met behulp van overbelasting. Overbelasting gebeurt op twee manieren, namelijk overbelasting van de methode en overbelasting door de operator.

Methode-overbelasting is de techniek waarbij we meer dan één methode hebben met dezelfde naam maar met verschillende parameterlijsten. De parameterlijst is gedifferentieerd op basis van het aantal parameters, soorten parameters of volgorde van parameters.

Overbelasting van operators in Java is beperkt en het stelt ons in staat om alleen de ‘+’ operator te overbelasten die wordt gebruikt om twee getallen toe te voegen en twee String-objecten samen te voegen.

Overbelasting wordt tijdens het compileren opgelost en is statisch. Het wordt ook wel ‘Vroege binding’ ​

Method Overriding is een functie waarmee we runtime-polymorfisme implementeren. Bij methode overschrijven wordt een methode van de bovenliggende klasse overschreven in de onderliggende klasse. Dit betekent dat het methode-prototype in zowel super- als subklasse hetzelfde blijft, maar dat de implementaties anders zijn.

Methode-overschrijving maakt gebruik van de dynamische methode-dispatch-techniek om de methodeaanroep op te lossen en te beslissen of een superklasse- of subklassemethode moet worden aangeroepen, en dit gebeurt tijdens runtime.

Daarom wordt runtime-polymorfisme ook wel dynamisch polymorfisme of late binding genoemd.

Laten we vervolgens de verschillen tussen overbelasting en overschrijving in Java in tabelvorm weergeven.

Overbelasting versus overschrijven in Java

Veel Gestelde Vragen

V # 1) Kunnen we de statische methode negeren?

Antwoord: Nee. Statische methoden kunnen in Java niet worden overschreven. Dit komt doordat statische methoden op klassen zijn gebaseerd en rechtstreeks door de klasse worden aangeroepen. Ze hebben geen objecten nodig om tijdens runtime aan te roepen. Daarom wordt de verzending van de statische methode bepaald door de compiler.

Vraag 2) Kunnen we de constructor opheffen?

Antwoord: Nee, we kunnen een constructor niet negeren. Een constructor wordt aangeroepen wanneer het object wordt gemaakt. Het wordt geen object genoemd. Een van de vereisten van overschrijven is ook de overschreven methode en de overschrijvende methode moet dezelfde methodehandtekening hebben, wat niet mogelijk is in het geval van constructors.

V # 3) Waarom wordt het overschrijven van methoden dynamisch polymorfisme genoemd?

Antwoord: In het geval van methode-overschrijving, wordt de methode-aanroep dynamisch tijdens runtime opgelost. Daarom wordt het dynamisch polymorfisme genoemd.

Vraag 4) Wat is het gebruik van dynamisch polymorfisme in Java?

Antwoord: Dynamisch polymorfisme maakt gebruik van een dynamische methode-verzendingstechniek die het overschrijven van methoden ondersteunt, zodat de subklasse een specifieke implementatie van de overschreven methode kan bieden. Op deze manier kunnen we de specifieke functies implementeren waarmee we efficiënte programma's kunnen schrijven.

Ten tweede hoeven we ons geen zorgen te maken over het oplossen van methodeaanroepen, aangezien dynamische methodeverzending beslist welke methode wordt aangeroepen.

V # 5) Wat is het verschil tussen statische en dynamische binding?

"de standaardgateway is niet beschikbaar"

Antwoord: De koppeling tussen een methodeaanroep en de implementatie ervan wordt binding genoemd. Wanneer deze koppeling tijdens het compileren wordt opgelost, noemen we dit statische binding. Wanneer de binding dynamisch wordt uitgevoerd tijdens runtime, noemen we dit dynamische binding.

De statische binding gebruikt het gegevenstype klasse en velden om methodeaanroepen op te lossen. De dynamische binding gebruikt objecten om methodeaanroepen op te lossen. Statische binding wordt ook wel compilatietijdpolymorfisme genoemd en dynamische binding wordt ook wel runtime-polymorfisme genoemd.

Gevolgtrekking

In deze tutorial hebben we runtime polymorfisme in Java in detail besproken.

Runtime-polymorfisme wordt geïmplementeerd met behulp van methode-overschrijving. Het overschrijven van een methode wordt gedaan in de subklasse waarin een methode die in de superklasse is gedefinieerd, opnieuw wordt gedefinieerd of overschreven in zijn subklasse. De handtekening van de methode blijft hetzelfde in de super- en subklasse.

Door methode te overschrijven kunnen we een specifieke implementatie bieden voor dezelfde methode in de subklasse. Op deze manier kunnen we efficiëntere programma's schrijven waarbij er sprake is van overerving. Java biedt @override-annotatie om aan te geven dat de methode moet worden overschreven.

Standaard zijn alle niet-statische methoden die niet definitief zijn, virtueel in Java. Alle virtuele methoden kunnen worden overschreven.

​ Bekijk hier de eenvoudige Java-trainingsserie.

Aanbevolen literatuur

• Vooraf gedefinieerde methoden in Java overschrijven
• Java String length () Methode met voorbeelden
• Wat is polymorfisme in Java - Tutorial met voorbeelden
• Hoe de Java toString-methode te gebruiken?
• Java String indexOf methode met codevoorbeelden
• Java String bevat () Method Tutorial met voorbeelden
• Java String Split () -methode - Hoe een string in Java te splitsen
• Java String CompareTo Method met programmeervoorbeelden