Inleiding tot runtime-polymorfisme op Java
In dit artikel gaan we meer te weten komen over het Runtime-polymorfisme op Java. "Poly" betekent "veel" en "morph" betekent "type". Dus de term polymorfisme geeft hetzelfde aan van verschillende typen. Hier zullen we zien hoe Java polymorfisme in runtime archiveert, wat betekent, na compilatie maar voordat de code wordt uitgevoerd.
Syntaxis:
Voor runtime-polymorfisme in Java moet u de basissyntaxis van Java met annotaties volgen. @Override annotatie kan hier worden gebruikt om specifiek aan te geven welke methode we willen overschrijven.
Hoe Runtime Polymorphism werkt in Java?
Runtime polymorphism werkt in Java door de methode te negeren. Het negeren van methoden vindt plaats wanneer objecten dezelfde methodenaam en argumenten en hetzelfde type hebben als de bovenliggende klasse, maar met verschillende functies. Als een kindklasse dat type methode bevat, noemen we het een overschreven methode.
Waarom wordt het runtime-polymorfisme genoemd?
wanneer we een onderdrukte methode van onderliggende klasse aanroepen via de verwijzing naar het bovenliggende type (dit fenomeen in Java wordt "Upcasting" genoemd), geeft het type object aan welke methode of functionaliteit wordt aangeroepen. Het nemen van deze beslissing gebeurt tijdens runtime door JVM na het compileren van code. Daarom wordt het Runtime polymorphism genoemd.
Het wordt ook wel "Dynamische verzendmethode" genoemd. Reden wordt zo genoemd, vanwege het feit dat de functionaliteit van de methode dynamisch wordt bepaald in runtime volgens het object door JVM
Het wordt ook "Late binding" genoemd, omdat binding van methode en object, wat betekent dat de functionaliteit van de methode van het object wordt weergegeven, laat wordt besloten, dwz na compilatie.
Regels en beperkingen in Runtim e Polymorphism
Hieronder vindt u enkele regels en beperkingen van runtime-polymorfisme:
Regels voor runtime-polymorfisme
- Methoden van kind- en ouderklasse moeten dezelfde naam hebben.
- Methoden van kind- en ouderklasse moeten dezelfde parameter hebben.
- IS-A-relatie is verplicht (overerving).
Beperkingen van runtime-polymorfisme
- Men kan privémethoden van een ouderklasse niet overschrijven.
- Men kan Final-methoden niet opheffen.
- Men kan statische methoden niet negeren.
Voorbeelden van runtime-polymorfisme op Java
We zullen hier enkele codevoorbeelden van Runtime polymorfisme bespreken.
Voorbeeld 1
In dit voorbeeld laten we zien hoe de methode showcase () verschillende berichten weergeeft, afhankelijk van het type object waaraan het is gekoppeld. Wanneer het is gekoppeld aan het type "Ouders", worden berichten van de bovenliggende klasse weergegeven. Terwijl, wanneer het wordt geassocieerd met het type "Kinderen", het berichten van de kindklasse toont.
Code:
class Parents (
public void showcase () (
System.out.println("I am Parent");
)
)
class Children extends Parents (
@Override
public void showcase () (
System.out.println("I am Children");
)
)
public class RunTimePolymorphism (
public static void main(String args()) (
Parents superObject = new Parents();
superObject.showcase(); //method of super class or parent class is called
Parents subObject = new Children(); // upcasting
subObject.showcase();//method of sub class or child class is called by Parent reference, this is called "Run time Polymorphism"
Children subObject2 = new Children();
subObject2.showcase(); //method of sub class or child class is called
)
)
Output:
Voorbeeld 2
Laten we een voorbeeld nemen van runtime-polymorfisme in het geval van overerving op meerdere niveaus. In dit voorbeeld hebben we rekening gehouden met twee niveaus van overerving. In dit voorbeeld laten we zien hoe de methode sip () verschillende berichten weergeeft, afhankelijk van het type object waaraan het is gekoppeld. Wanneer het wordt geassocieerd met het type 'Mens', worden berichten van een bovenliggende klasse weergegeven. Terwijl, wanneer het wordt geassocieerd met het type "Man", het berichten van de onderliggende klasse toont. Nogmaals, in het tweede niveau van overerving, wanneer het wordt geassocieerd met het type "Baby", toont het berichten van de onderliggende klasse van de ouder die de klasse "Man" is.
Code:
class Human(
void sip() (
System.out.println("Human is sipping");
)
)
class Man extends Human(
void sip()(
System.out.println("Man is sipping soup");
)
)
class Baby extends Man(
void sip()(
System.out.println("Baby is sipping milk");
)
)
public class RunTimePolymorphism (
public static void main(String args())(
Human superObject=new Human();
Human subObject=new Man(); // // upcasting : first level of heritance
Human babyObject=new Baby(); // // upcasting : second level of heritance
superObject.sip();
subObject.sip(); //run time polymorphism happening in first level of heritance
babyObject.sip(); //run time polymorphism happening in second level of heritance
)
)
Output:
Voorbeeld 3
Laten we nog een voorbeeld nemen van runtime-polymorfisme in het geval van overerving op meerdere niveaus. In dit voorbeeld hebben we drie niveaus van overerving in acht genomen. In dit voorbeeld laten we zien hoe de methode feature () verschillende functies weergeeft, afhankelijk van het type object waaraan het is gekoppeld. Wanneer het is gekoppeld aan het type 'besturingssysteem', worden berichten van een bovenliggende klasse weergegeven. Terwijl, wanneer het wordt geassocieerd met het "DOS" -type, het berichten van de onderliggende klasse toont. Opnieuw in het tweede niveau van overerving, wanneer het wordt geassocieerd met het type "Windows", toont het berichten van de onderliggende klasse van de bovenliggende klasse die de klasse "DOS" is. Opnieuw in het derde niveau van overerving, wanneer het wordt geassocieerd met het type "WindowsMobile", toont het berichten van de onderliggende klasse van de bovenliggende klasse die de klasse "Windows" is.
Code:
class OperatingSytem(
void feature() (
System.out.println("This is Operating Sytem");
)
)
class DOS extends OperatingSytem(
void feature()(
System.out.println("This is DOS");
)
)
class Windows extends DOS(
void feature()(
System.out.println("This is Windows");
)
)
class WindowsMobile extends Windows(
void feature()(
System.out.println("This is Windows Mobile");
)
)
public class RunTimePolymorphism (
public static void main(String args())(
OperatingSytem superObject=new OperatingSytem();
OperatingSytem subObject=new DOS(); // child object type : first level of heritance
OperatingSytem sub2Object=new Windows(); // child object type : second level of heritance
OperatingSytem sub3Object=new WindowsMobile(); // child object type : third level of heritance
superObject.feature();
subObject.feature(); //run time polymorphism happening in first level of heritance
sub2Object.feature(); //run time polymorphism happening in second level of heritance
sub3Object.feature(); //run time polymorphism happening in third level of heritance
)
)
Output:
Conclusie
Hiermee is onze kennis van het onderwerp "Runtime Polymorphism in Java" afgesloten. Schrijf de codes in de bovenstaande voorbeelden in de Java-compiler en verifieer de uitvoer. Het leren van codes is onvolledig als u niet zelf code schrijft.
Aanbevolen artikelen
Dit is een leidraad geweest voor Runtime Polymorphism in Java. Hier bespreken we hoe Runtime Polymorphism in Java werkt met voorbeelden. U kunt ook de volgende artikelen bekijken voor meer informatie -
- Statisch trefwoord in Java
- Overschrijven in Java
- Wat is polymorfisme?
- Roest versus Golang