Introduktion om Överridande i OOP
Vid implementering av arvskonceptet i oops används alla funktioner i förälderklassen av alla dess härledda klasser. Men om en härledd klass vill ha den specifika implementeringen av den funktion som har deklarerats i moderklassen men som använder samma namn, samma signatur och samma returtyp används övervägande funktion. Överskridande gör det möjligt för barnklass att omdefiniera den funktion som redan har definierats i sin överordnade klass eller superklass. På detta sätt kan man använda båda definitionerna genom att ange klassens objekt medan man kallar metoden. Till exempel, låt det finnas en sumfunktion i både förälder- och barnklass och samtidigt som vi kallar funktionen använder vi objektet för barnklass kommer den metod som finns i barnklassen att kallas och istället om du använder föräldraklassobjekt så kommer metoden närvarande i förälderklassen kommer att kallas. denna metod i barnklassen sägs åsidosätta metoden som finns i dess superklass.
Behov av att överstiga metoder
Följande är metoderna för att åsidosätta:
- Runtime polymorfismmetoden åsidosätter hjälper till att uppnå runtime polymorfism i objektorienterade programmeringsspråk som c ++, java, c #, etc.
- Polymorfism betyder att man har många former, dvs en signatur och flera definitioner. på objektorienterade språk när både härledda och överordnade klassen har samma namn och signatur för en funktion då löser kompilatoren en gång definitionen behöver den ringa. Runtime polymorfism innebär bindning av en metoddefinition till en metod som kallas sker vid körning av ett program. Det möjliggör implementering av "en signatur multipeldefinition" aspekt av polymorfism. Denna funktion använder dynamisk metodsändning som har ett kraftfullt koncept av objektorienterad design för att få kodanvändning och robusthet. Att åsidosätta en metod tillåter oss ett metodsamtal till någon av dess härledda klasser utan att känna till typen av objekt i den härledda klassen.
- Genom att använda denna funktion kan man implementera specialiserad definition till generisk funktion som ärvs från dess superklass.
Hur fungerar överkörning i OOP: er?
Nedanstående förklaring säger att hur överskridande fungerar:
- OOP, hjälp oss att implementera runtime polymorfism medan vi ärver en klassfunktioner till en annan. Låt oss ta en titt på hur man överskrider i OOP. Senare antar vi att vi har ett superklassklassdjur som har två funktioner som talar och äter. Det finns två underklasser katt och hund som utvidgar djuret med superklassens namn.
- Dessa två underklasser använder samma funktioner som talar och äter men ändrar implementeringen men behåller signaturerna på metoderna på samma sätt. I vår huvudmetod, om du anropar dessa funktioner för att välja referensvariabel, kommer det bara att köras under körning vilken funktion den behöver för att ringa. Till exempel, om objektet har skillnaden mellan barnklass som är katt eller hund, kommer funktionen för respektive klass att kallas annars om objektet har referensen till förälderklassen kommer funktionen för en djurklass att kallas.
- Här bör vi se att funktionen kallas inte beror på typen av referensvariabel. Detta bestäms av kompilatorn vid körning, bara det hjälper till att implementera runtime-polymorfism. Det hjälper också till att implementera den specialiserade definitionen av metoden för den generiska definitionen av metod i förälderklassen.
Koda:
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();
)
)
Produktion:
Obs: En referensvariabel av barntyp kan inte användas för att hålla en referens till föräldertypen.
Regler för att åsidosätta en metod
Följande är reglerna för åsidosättande:
Regel 1
En lista över de parametrar som deklarerats i funktionen av förälderklassen bör matcha listan med parametrarna som nämns i definitionen av övervägande metod i barnklass.
Till exempel:
Metoden i förälderklassen
public int test1(int a);
En metod i barnklass - public string test1 (); // metodöverskridande stöds inte här eftersom returtyp och argument är olika men inget fel i kompileringstiden kommer att komma. Denna metod kommer att betraktas som en ny metod för en barnklass.
Regel 2
Returtypen för metoden som finns i barnklassen måste vara densamma eller en subtyp av returtypen för metoden som åsidosätts.
Till exempel:
Metoden i en förälderklass
public Object test1(int a);
Metoden i barnklassen
public String test1();
Felaktig
Metoden i förälderklassen
public String test1(int a);
Metoden i barnklassen
public Object test1();
Regel 3
Den åtkomstspecifikation som finns i metoden för föräldraklassen måste vara lika begränsande eller mer restriktiv än metoden som åsidosätter den i barnklassen.
Felaktig
Metoden i förälderklassen
public int test1(int a);
Metod i barnklassen
private int test1() ; // more restrictive than public one
Regel 4
Endast instansmetoden med åtkomstspecifikation som offentligt skyddad eller standard kan åsidosättas. Detta beror på att endast den här instansmetoden kan ärvas av dess underklass och därmed sägas åsidosättas. Om instansmetoden som anges i förälderklassen är mer restriktivt exempel på offentlig metod kommer den inte att ärvas i dess underklass och gör om någon definierar samma metod i en underklass det scenariot inte tas som en metod som överskrider eftersom offentliga metoder inte kan vara ärvt detta kan inte åsidosättas.
Till exempel:
Metoden i förälderklassen
public int test1(int a); //can be inherited and overridden
Metoden i barnklassen
private int test1();
Felaktig
Metoden i förälderklassen
private int test1(int a); //can not be inherited and overridden
Metoden i barnklassen
private int test1();//not overriding method of the parent class
Det betraktas som en ny privat metod för barnklassen
Regel 5
Super-nyckelordet kan användas för att kalla funktionen för föräldraklass som har åsidosatts av dess underklass.
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();
)
)
Produktion:
Regel 6
En klasskonstruktör kan inte åsidosättas av dess underklasser eftersom en konstruktör av två klasser inte kan vara densamma.
Regel 7
Undantagshantering vid övervägande.
- Incase-metoden i förälderklassen kastar inget undantag då den övervägande metoden som finns i underklassen får kasta ett enda okontrollerat undantag. Om den övergripande metoden visar det kontrollerade undantaget visar kompilatorn ett fel.
- Om metoden i den överordnade klassen som åsidosätts kastar ett undantag tandem åsidosättande metod som finns i underklassen måste genom ett undantag av samma nivå eller dess subtyp i undantagshierarkin eller inget undantag alls.
Regel 8
Metodöverskridande i arv i flera nivåer är också möjlig.
Koda:
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();
)
)
Produktion:
Regel 9
Regler för åsidosättningsmetod i Java
- En synkroniserad metod kan enkelt åsidosättas med en icke-synkroniserad metod och vice versa.
- Abstrakt metod som finns i abstrakta klasser eller gränssnitt är tänkt att skrivas över för att ge specifik implementering av de deklarerade metoderna annars kommer det att visa ett kompileringstidsfel.
- Att definiera en statisk metod med samma namn som en statisk metod som finns i förälderklassen kallas metod som döljer inte metodöverskridande eftersom den inte implementerar runtime-polymorfism.
- Slutliga metoder kan inte åsidosättas.
Regel 10
Överträffande metod i C ++
Överskridande metod i c plus uppnås genom att deklarera en metod som virtuell. Ett virtuellt nyckelord används för att uppnå runtime polymorfism i c ++. Medan Java alla funktioner som standard tas som virtuella.
Regel 11
Metodöverskridande skiljer sig från metodöverbelastning eftersom det är en process för runtime-polymorfism medan överbelastning och metod är ett exempel på kompileringstid-polymorfism. Vid åsidosättande av metod är det obligatoriskt att hålla metodens signatur densamma. när vi gör några ändringar i metodens returtyp eller parameterlista, behandlar kompilatorn det som överbelastning av metoden.
| Metodöverskridande | Metod överbelastning |
class A( | class A( |
Produktion:
 |  |
När ska man använda metodöverskridande?
Följande är metoderna för att använda Overriding:
- OOP ger ett underbart drag i arv för att bilda en stor hierarki mellan superklass och underklass är från mindre specialisering till större specialisering.
- Kan vi använda superklassen för att tillhandahålla en ram som kan ärvas i alla dess underklasser och underklasserna kan vi definiera de olika funktionerna i dessa metoder. Detta uppnås genom en övervägande funktion där specialiserad funktion kan tillhandahållas till de ärvda metoderna i underklasser.
- Det hjälper också till att skapa ett ramverk för flera klasser genom att tillhandahålla en samling variabler och metoden som måste implementeras i alla dess underklasser.
Slutsats
OOP: er, koncept gör kod robust och lätt att återanvända när de används effektivt. Den övervägande funktionen förbättrar användningen av arv för att tillhandahålla den specifika implementeringen av den generiska metoden för moderklassen i dess underklasser. Detta använder runtime polymorfism-konceptet för att utlösa rätt definition av metod. Dynamisk metodsändning görs endast under körning som kontrollerar referensen för klass som objektet håller för att kalla metoden. Denna funktion styrs av olika regler och gäller inte för statiska metoder. Vi kan implementera metodöverskridande på alla objektorienterade språk och göra vårt program snabbare och robust.
Rekommenderade artiklar
Detta är en guide till Överridering i OOP. Här diskuterar vi hur överskridande fungerar i OOP, när den ska användas, och 11 regler med koder och utdata. Du kan också gå igenom våra andra relaterade artiklar för att lära dig mer-
- Övergripande i PHP
- Överbryter i JavaScript
- Vad är OOP?
- Metodöverskridande i C #
- Exempel på åsidosättande i Java
- Statisk metod för JavaScript | Hur man arbetar med exempel