Inleiding over negeren in OOP's
Bij het implementeren van het overervingsconcept in oeps worden alle functies in de bovenliggende klasse gebruikt door alle afgeleide klassen. Maar in het geval als een afgeleide klasse de specifieke implementatie van de functie wil die in de bovenliggende klasse is gedeclareerd maar dezelfde naam, dezelfde handtekening en hetzelfde retourtype gebruikt, wordt de overheersende functie gebruikt. Met Overschrijven kan de onderliggende klasse de functie opnieuw definiëren die al is gedefinieerd in de bovenliggende klasse of superklasse. Op deze manier kan men zowel de definitie gebruiken door het object van de klasse op te geven terwijl de methode wordt aangeroepen. Laat er bijvoorbeeld een somfunctie zijn in zowel de ouder- als de kindklasse en terwijl we de functie aanroepen, gebruiken we het object child-klasse, dan wordt de methode die in de child-klasse aanwezig is aangeroepen en in plaats daarvan als u het ouderklasse-object gebruikt, dan is de aanwezige methode in de bovenliggende klasse wordt genoemd. van deze methode in de kindklasse wordt gezegd dat deze de methode overschrijft die aanwezig is in de superklassen.
Noodzaak voor methode overschrijven
Hier volgen de methoden voor het negeren:
- Runtime polymorphism methode overriding helpt om runtime polymorphism te bereiken in object-georiënteerde programmeertalen zoals c ++, java, c #, etc.
- Polymorfisme betekent dat er veel vormen zijn, dwz één handtekening en meerdere definities. in objectgeoriënteerde talen wanneer zowel de afgeleide als de bovenliggende klasse dezelfde naam en handtekening van een functie heeft, moet deze bij eenmalige compiler de definitie aanroepen. Runtime polymorfisme betekent dat binding van een methodedefinitie aan een methode die wordt genoemd plaatsvindt tijdens runtime van een programma. Het maakt het mogelijk om "één kenmerk meervoudige definitie" aspect van polymorfisme te implementeren. Deze functie maakt gebruik van dynamische methode verzending die een krachtig concept van object-georiënteerd ontwerp heeft om code hergebruik en robuustheid te brengen. Als u een methode overschrijft, kunnen we een methode aanroepen voor een van de afgeleide klassen zonder het type object van de afgeleide klasse te kennen.
- Met behulp van deze functie kan een gespecialiseerde definitie worden geïmplementeerd voor een generieke functie die is overgenomen van de superklasse.
Hoe werkt Overriding in OOP's?
De onderstaande uitleg zegt dat het opheffen werkt:
- OOP's, helpen ons om runtime polymorfisme te implementeren terwijl we een klasse-functie overnemen in een andere. Laten we eens kijken naar de werking van overschrijven in OOP's. Stel later dat we een superklasse naam dier hebben met twee functies spreken en eten. Er zijn twee subklassen kat en hond die de superklasse-naam dier uitbreiden.
- Deze twee subklassen gebruiken dezelfde functies spreken en eten maar veranderen de implementatie maar houden de handtekening van de methoden hetzelfde. Als u in onze hoofdmethode deze functies aanroept en de referentievariabele kiest, wordt tijdens runtime alleen bepaald welke functie moet worden aangeroepen. Als het object bijvoorbeeld het verschil bevat van de kindklasse die kat of hond is, wordt de functie van een respectieve klasse anders aangeroepen. Als het object de referentie van de bovenliggende klasse bevat, wordt de functie van een dierklasse genoemd.
- Hier moeten we zien dat de functie die wordt aangeroepen niet afhankelijk is van het type referentievariabele. Dit wordt besloten door de compiler tijdens runtime, alleen helpt het om runtime polymorfisme te implementeren. Het helpt ook om de gespecialiseerde definitie van de methode van de generieke definitie van methode in de bovenliggende klasse te implementeren.
Code:
class Animal(
//Overridden method
public void eat()
(
System.out.println("Animal is eating");
)
public void speak()
(
System.out.println("Animal is speaking");
)
)
class Cat extends Animal(
//Overriding method
public void eat()
(
System.out.println("Cat is eating");
)
public void speak()
(
System.out.println("Cat is meowing");
)
)
class Dog extends Animal(
//Overriding method
public void eat()
(
System.out.println("Dog is Barking");
)
public void speak()
(
System.out.println("Dog is speaking");
)
)
public class Test(
public static void main(String() args)(
Animal an=new Dog();
Animal an1 = new Cat();
Animal an2 = new Animal();
an.speak();
an.eat();
an1.speak();
an1.eat();
an2.eat();
)
)
Output:
Opmerking: een referentievariabele van het kindtype kan niet worden gebruikt om een verwijzing naar het oudertype te bevatten.
Regels voor het opheffen van een methode
Hier volgen de regels voor het opheffen:
Regel 1
Een lijst met parameters die zijn opgegeven in de functie van bovenliggende klasse, moet overeenkomen met de lijst met parameters die worden genoemd in de definitie van de vervangende methode in onderliggende klasse.
Bijvoorbeeld:
De methode in de bovenliggende klasse
public int test1(int a);
Een methode in onderliggende klasse - public string test1 (); // methode overschrijven wordt hier niet ondersteund omdat het retourtype en de argumenten verschillen, maar er zal geen compilatietijd optreden. Deze methode wordt beschouwd als een nieuwe methode voor een kindklasse.
Regel # 2
Het retourtype van de methode in de onderliggende klasse moet hetzelfde zijn of een subtype van het retourtype van de methode die wordt genegeerd.
Bijvoorbeeld:
De methode in een ouderklasse
public Object test1(int a);
De methode in de kindklasse
public String test1();
Niet correct
De methode in de bovenliggende klasse
public String test1(int a);
De methode in de kindklasse
public Object test1();
Regel # 3
De toegangsspecificatie die aanwezig is in de methode van de bovenliggende klasse, moet even beperkend of restrictiever zijn dan de methode die deze vervangt in de onderliggende klasse.
Niet correct
De methode in de bovenliggende klasse
public int test1(int a);
Methode in de kindklasse
private int test1() ; // more restrictive than public one
Regel # 4
Alleen de instantiemethode met toegangsspecificatie als openbaar beveiligd of standaard kan worden genegeerd. Dit komt omdat alleen deze instantiemethode kan worden geërfd door de subklasse en dus wordt overschreven. In het geval dat de instantiemethode die in de bovenliggende klasse is gespecificeerd, een beperktere voorbeeld openbare methode is, wordt deze niet overgenomen in de subklasse en als iemand dezelfde methode in een subklasse definieert, wordt dat scenario niet als een methode beschouwd die kan worden overschreven omdat openbare methoden niet kunnen worden geërfd, kan dit niet worden opgeheven.
Bijvoorbeeld:
De methode in de bovenliggende klasse
public int test1(int a); //can be inherited and overridden
De methode in de kindklasse
private int test1();
Niet correct
De methode in de bovenliggende klasse
private int test1(int a); //can not be inherited and overridden
De methode in de kindklasse
private int test1();//not overriding method of the parent class
Het wordt beschouwd als een nieuwe privémethode van de kindklasse
Regel # 5
Het super-sleutelwoord kan worden gebruikt om de functie van de bovenliggende klasse aan te roepen die door de subklasse is overschreven.
class Animal(
//Overridden method
public void eat()
(
System.out.println("Animal is eating");
)
public void speak()
(
System.out.println("Animal is speaking");
)
)
class Dog extends Animal(
//Overriding method
public void eat()
(
System.out.println("Dog is Barking");
)
public void speak()
(
super.speak(); // Here super keyword is used to call the speak function of the super class.ieAnimal
)
)
public class Test(
public static void main(String() args)(
Animal an=new Dog();
Animal an2 = new Animal();
an.speak();
an.eat();
an2.eat();
)
)
Output:
Regel # 6
De constructor van een klasse kan niet worden overschreven door zijn subklassen, aangezien een constructor van twee klassen niet hetzelfde kan zijn.
Regel # 7
Uitzonderingsafhandeling bij overschrijven.
- Incase-methode in de bovenliggende klasse genereert geen uitzondering, dan mag de dwingende methode in de subklasse een enige ongecontroleerde uitzondering genereren. In het geval dat de overheersende methode een aangevinkte uitzondering vertoont, zal de compiler een foutmelding geven.
- Als de methode in de bovenliggende klasse die wordt genegeerd, een uitzonderings tandem-override-methode in de subklasse genereert, moet dit via een uitzondering van hetzelfde niveau of het subtype ervan in de uitzonderingshiërarchie of helemaal geen uitzondering.
Regel # 8
Methode opheffen in overerving op meerdere niveaus is ook mogelijk.
Code:
class Creature (
//Overriding method
public void eat()
(
System.out.println("Creature is eating");
)
public void speak()
(
System.out.println("Creature is speaking");
)
)
class Animal extends Creature(
//Overridden method
public void eat()
(
System.out.println("Animal is eating");
)
public void speak()
(
System.out.println("Animal is speaking");
)
)
class Dog extends Animal(
//Overriding method
public void eat()
(
System.out.println("Dog is Barking");
)
public void speak()
(
System.out.println("Dog is speaking");
)
)
public class Test(public static void main(String() args)(
Creature an=new Dog();
Animal an1 = new Animal();
Animal an2 = new Dog();
an.speak();
an.eat();
an1.speak();
an1.eat();
an2.eat();
)
)
Output:
Regel # 9
Regels voor overheersende methoden in Java
- Een gesynchroniseerde methode kan gemakkelijk worden opgeheven door een niet-gesynchroniseerde methode en vice versa.
- De abstracte methode die aanwezig is in abstracte klassen of interfaces is bedoeld om te worden overschreven om een specifieke implementatie van de aangegeven methoden te bieden, anders zal er een compilatie-fout optreden.
- Het definiëren van een statische methode met dezelfde naam als een statische methode die aanwezig is in de bovenliggende klasse, wordt methode verbergen en niet methode negeren genoemd omdat het runtime polymorfisme niet implementeert.
- Definitieve methoden kunnen niet worden opgeheven.
Regel # 10
Methode overschrijven in C ++
Methode overschrijven in c plus wordt bereikt door een methode als virtueel te verklaren. Een virtueel trefwoord wordt gebruikt om runtime polymorfisme te bereiken in c ++. Terwijl in Java alle functies standaard als virtueel worden beschouwd.
Regel # 11
Methode overschrijven verschilt van methode overbelasting, omdat het een proces van runtime polymorfisme is, terwijl overbelasting en methode een voorbeeld is van compileertijd polymorfisme. Bij het opheffen van de methode is het verplicht om de handtekening van de methode hetzelfde te houden. wanneer we wijzigingen aanbrengen in het methode-retourtype of de parameterlijst, behandelt de compiler het als methode-overbelasting.
| Methode opheffen | Methode Overbelasting |
class A( | class A( |
Output:
 |  |
Wanneer methode overschrijven gebruiken?
Dit zijn de methoden om Overriding te gebruiken:
- OOP's biedt een prachtige eigenschap van overerving om een grote hiërarchie tussen superklasse en subklasse te vormen, van kleinere specialisatie tot grotere specialisatie.
- Kunnen we de superklasse gebruiken om een raamwerk te bieden dat kan worden geërfd in alle subklassen en de subklassen, dan kunnen we de verschillende werking van die methoden definiëren. Dit wordt bereikt door de overheersende functie, waarbij gespecialiseerde functies kunnen worden geleverd aan de overgeërfde methoden init subklassen.
- Het helpt ook om een raamwerk te bieden voor meerdere klassen door een verzameling variabelen te bieden en de methode die in al zijn subklassen moet worden geïmplementeerd.
Conclusie
OOP's, concepten maken code robuust en gemakkelijk opnieuw te gebruiken wanneer ze effectief worden gebruikt. De overheersende functie verbetert het gebruik van overerving om de specifieke implementatie van de generieke methode van bovenliggende class.in zijn subklassen te bieden. Dit maakt gebruik van het runtime-polymorfismeconcept om de juiste definitie van de methode te activeren. Het verzenden van dynamische methoden vindt alleen plaats tijdens runtime, waarbij de referentie wordt gecontroleerd van de klasse die het object vasthoudt om de methode aan te roepen. Deze functie wordt door verschillende regels geleid en is niet van toepassing op statische methoden. We kunnen methoden overschrijven in elke objectgeoriënteerde taal en ons programma sneller en robuuster maken.
Aanbevolen artikelen
Dit is een gids voor overschrijven in OOP's. Hier bespreken we hoe opheffen werkt in OOP's, wanneer het moet worden gebruikt, en 11 regels met codes en uitvoer. U kunt ook onze andere gerelateerde artikelen doornemen voor meer informatie-
- Overschrijven in PHP
- Overschrijven in JavaScript
- Wat is OOP?
- Methode overschrijven in C #
- Voorbeelden van opheffen in Java
- JavaScript statische methode | Hoe te werken met voorbeelden