what is polymorphism java tutorial with examples
In deze tutorial wordt uitgelegd wat polymorfisme in Java is, soorten polymorfisme en hoe polymorfisme tijdens compilatie kan worden geïmplementeerd met voorbeelden:
Het woord 'polymorfisme' is afgeleid van twee woorden, d.w.z. 'Poly' wat veel betekent en ' morphs ”Betekenis vormen. Polymorfisme betekent dus vele vormen. In een programmeertaal kunnen we zeggen dat een object vele vormen kan aannemen, en daarom is het object polymorf.
Polymorfisme is een van de belangrijkste kenmerken van OOP en het stelt ons in staat om een kenmerk (een object of een bericht of methode of een operator) in verschillende vormen uit te drukken.
Bekijk hier de Java-beginnershandleiding.
Wat je leert:
Inleiding tot polymorfisme in Java
De polymorfe entiteit gedraagt zich anders onder verschillende scenario's.
Bijvoorbeeld, overweeg een ‘+’ (toevoeging) operator in Java. Dit is een binaire operator en er zijn twee operanden nodig. Als de operanden die worden doorgegeven aan de ‘+’ operator getallen zijn, wordt een optelbewerking uitgevoerd die de som van twee getallen retourneert.
Wanneer operanden veranderen in String-type, voegt de ‘+’ operator de String-objecten niet toe, maar voegt de inhoud van de string samen of voegt deze samen om een resulterende derde string te vormen.
Bijvoorbeeld, als ' een 'En' twee ”Zijn dan de inhoud van twee String-objecten 'Een' + 'twee' zal resulteren in ' een twee Dit is aaneenschakeling.
In Java zijn alle objecten polymorf omdat ze allemaal zijn afgeleid van de klasse 'Object' en dus voldoen aan de 'IS-A' -relatie met de klasse Object.
Een object is altijd toegankelijk via een referentievariabele van dat specifieke klassetype. Zodra een referentievariabele van een bepaald type is gedeclareerd, kan deze niet worden gewijzigd. Als de referentievariabele echter niet is gedeclareerd als ‘Final’, kunnen we deze opnieuw toewijzen om naar andere objecten te verwijzen.
Het type van deze objectverwijzing bepaalt de klassemethoden of -functies die moeten worden aangeroepen.
Bijvoorbeeld,als er een ABC-klasse en klasse XYZ is afgeleid van ABC, hebben beide klassen een polymorfe methode func ().
Laten we een referentie maken van het type ABC.
beste systeemoptimalisatie voor Windows 10
Als we nu de methode func () aanroepen, aangezien het object waarnaar obj verwijst van klasse XYZ is, wordt de methode func () van de klasse XYZ aangeroepen.
Zoals we in het bovenstaande voorbeeld hebben gezien, heeft de methode func () verschillende implementaties maar hetzelfde prototype. Afhankelijk van het object dat wordt aangewezen door het referentieobject, hebben we de juiste implementatie in dat scenario aangeroepen. Dit is polymorfisme.
Laten we polymorfisme in Java in detail bespreken.
Voorbeeld van Java-polymorfisme
Laten we een eenvoudig voorbeeld van polymorfisme in Java bekijken met de optelbewerking zoals eerder besproken.
Hier gebruiken we twee methoden met dezelfde naam maar met verschillende parameters. De eerste functie accepteert twee integer-parameters en de tweede methode accepteert twee stringparameters.
Afhankelijk van het type parameters dat wordt doorgegeven, wordt de juiste methode aangeroepen en worden ofwel twee gehele getallen toegevoegd en het resultaat afgedrukt, ofwel worden de twee strings samengevoegd en wordt de resulterende string afgedrukt.
Het Java-programma wordt hieronder gegeven:
Uitgang:
Hier hebben we gezien dat wanneer we de eerste keer dat we twee integer-parameters doorgeven aan de addition_func, de eerste methode wordt aangeroepen. In de tweede functieaanroep geven we twee String-type parameters door, en daarom wordt de tweede overbelaste methode aangeroepen.
Soorten polymorfisme
Java ondersteunt twee soorten polymorfisme:
- Compilatietijd polymorfisme
- Runtime polymorfisme
Zoals de naam doet vermoeden, wordt het polymorfisme tijdens het compileren uitgevoerd tijdens het compileren en wordt het polymorfisme tijdens de uitvoering tijdens de uitvoering uitgevoerd.
Zoals te zien is in de bovenstaande afbeelding, wordt Compile-time polymorfisme geïmplementeerd door middel van overbelasting. We kunnen zowel de methode als de operator overbelasten. Runtime-polymorfisme wordt bereikt door middel van Overriding.
In deze tutorial zullen we Compile-time polymorfisme in detail bespreken. In de volgende tutorial zullen we runtime polymorfisme behandelen.
Compilatietijdpolymorfisme in Java
Compilatietijd polymorfisme is ook bekend als 'statisch polymorfisme'. Als onderdeel van het polymorfisme tijdens het compileren, wordt elk polymorfisme dat moet worden uitgevoerd, tijdens het compileren uitgevoerd.
In Java wordt het compilatietijdpolymorfisme uitgevoerd met ' Methode overbelasting Met behulp van methode-overbelasting kunnen we een of meer methoden hebben met dezelfde naam en alleen gedifferentieerd op basis van nummers of type of volgorde van parameters.
Overbelasting van methoden is de meest voorkomende implementatie van compilatietijdpolymorfisme in Java. Java ondersteunt ook overbelasting van operators.
Wat is overbelasting in Java in het algemeen?
Overbelasting in Java is een proces waarbij meer dan één methode wordt gebruikt met dezelfde naam en hetzelfde retourtype, maar die verschillen in volgorde, aantal en typen argumenten. Het wordt in het algemeen ook wel methode-overbelasting genoemd.
Methode overbelasting in Java
Overbelasting van methoden is een implementatie van compilatietijdpolymorfisme in Java. Als we een of meer methoden hebben met dezelfde naam en / of retourtypen maar verschillende parameterlijsten, dan zeggen we dat we de methoden hebben 'overbelast'.
Dus in een bepaalde klasse kunnen we verschillende methoden hebben met dezelfde naam maar met verschillende argumentlijsten.
Hoe gebruiken we overbelaste methoden? Of hoe weet de compiler welke methode moet worden aangeroepen?
Het aanroepen van de exacte methode die overeenkomt met de aanroep wordt uitgevoerd afhankelijk van de parameterlijst.
We hebben al gezien dat een klasse in Java meer dan één constructor kan hebben. In het geval van constructors is de argumentenlijst of de argumenten die de constructor accepteert in alle constructors anders. Dit is een voorbeeld van overbelasting. Overbelasting van constructeurs is dus een basisvorm van overbelasting van methoden in Java.
Laten we nu eens kijken hoe u een methode in Java overbelast?
Java biedt drie manieren om methoden te overbelasten, afhankelijk van de variaties in de parameter- / argumentlijst.
# 1) Type parameters
We kunnen methoden in Java overbelasten, afhankelijk van het gegevenstype van parameters.
Beschouw het volgende voorbeeld waarin we prototypes van drie methoden hebben gegeven.
toevoeging (int, int);
toevoeging (int, float);
toevoeging (String, String);
Zoals hierboven kan worden gezien, hebben we in alle drie de gevallen dezelfde methode-naam en hetzelfde aantal parameters, maar elke methode-aanroep heeft verschillende soorten parameters.
Dus zolang methoden verschillende soorten parameters hebben, kunnen we zeggen dat de methoden overbelast zijn. Wanneer we de methode aanroepen, beslist de compiler over het datatype van de parameter, en afhankelijk van het datatype van de parameterlijst die bij de methodeaanroep wordt geleverd, wordt de juiste methode aangeroepen.
Bijvoorbeeld,als we een methodeaanroep hebben zoals hieronder:
toevoeging (3, 3,5);
In de bovenstaande methodeaanroep kunnen we zien dat de eerste parameter het int-type is, terwijl de tweede parameter het float-type is. Wanneer de bovenstaande oproep wordt aangetroffen, lost de compiler de parameterlijst op en roept vervolgens de juiste methode aan, de tweede methode hierboven.
Laten we nu een compleet Java-programma implementeren om de overbelasting van de methode te demonstreren op basis van de gegevenstypen van parameters.
Uitgang:
# 2) Aantal parameters
Een andere implementatie van methode-overbelasting is door methoden te overbelasten met een ander aantal parameters in de functieaanroep.
hoe u handmatig crossbrowser-tests kunt uitvoeren
Bijvoorbeeld,laten we eens kijken naar de volgende methodeverklaringen:
addnum (int, int);
addnum (int, int, int);
In de bovenstaande methodedeclaraties heeft de eerste methodedeclaratie twee parameters en de tweede declaratie drie parameters. Wanneer een functie wordt aangeroepen, inspecteert de compiler het aantal parameters en lost vervolgens de methodeaanroep op de juiste manier op.
Het onderstaande voorbeeld toont het programma dat methode-overbelasting gebruikt op basis van het aantal parameters.
Uitgang:
In dit voorbeeld hebben we twee methoden die overbelast zijn op basis van het aantal parameters. De eerste methode heeft één parameter nodig en de tweede methode heeft twee parameters. In de hoofdmethode roepen we beide methoden een voor een op en de compiler lost de functieaanroep op, afhankelijk van het aantal opgegeven parameters.
# 3) Volgorde van parameters
De derde benadering van het implementeren van methode-overbelasting is gebaseerd op de opeenvolging van parameters in overbelaste methoden.
Beschouw het volgende voorbeeld van de methode-declaratie,
som (int, float);
som (float, int);
Hier hebben we een overbelast methodesom. In de eerste declaratie zijn de parameters int en float. Ook in de tweede declaratie zijn de parameters int en float, maar hun volgorde in de parameterlijst is veranderd.
Nu verschijnt de float-parameter als eerste, terwijl de int-parameter de tweede is. We kunnen methode-overbelasting bereiken door de parametervolgorde te wijzigen.
De hieronder demonstreert het Java-programma dit.
Uitgang:
In het bovenstaande programma hebben we een overbelaste methode met printParam met int- en char-parameters waarvan de volgorde wordt gewijzigd in twee methode-declaraties.
Ongeldige gevallen van overbelasting van de methode
Tot dusver hebben we overbelasting van methoden besproken met behulp van de parameterlijst. We hebben nog niet nagedacht over het type retourmethode. Merk op dat we methoden op basis van retourtypen niet overbelasten.
Als twee methoden bijvoorbeeld dezelfde naam en dezelfde parameterlijsten hebben, maar verschillende retourtypen hebben, zeggen we niet dat deze twee methoden overbelast zijn. Dit geval wordt ongeldig wegens overbelasting.
Dus als we de volgende verklaringen hebben:
Ik int (int, int);
String som (int, int);
In dit geval geeft de compiler een foutmelding omdat twee methoden niet worden overbelast. Daarom zijn de methoden alleen op basis van de retourtypen niet gedifferentieerd.
hoe een wachtrij in java te instantiëren
Laten we dit ongeldige geval demonstreren met een Java-programma.
In het bovenstaande programma heeft de methode myMethod twee prototypes. Een prototype heeft twee int-parameters en retourneert dubbel. Het tweede methode-prototype heeft twee int-parameters en retourneert een int.
Dus als we dit programma compileren, krijgen we de onderstaande output.
Uitgang:
De bovenstaande compilatiefout geeft aan dat de methode tweemaal wordt gedeclareerd. Dit betekent dat de compiler deze methoden niet als overbelast beschouwt, louter op basis van het retourtype.
Operator overbelasting
Overbelasting door een operator is een overbelastingsmechanisme waarbij aan een bestaande operator een andere betekenis wordt gegeven.
Zoals we hebben besproken in het inleidende gedeelte van deze tutorial, is een opteloperator ‘+’ een klassiek voorbeeld van overbelasting door de operator.
Als de operanden van deze operator numeriek zijn, retourneert de operator + het totaal van twee waarden. Maar als de operanden van het type String zijn, is het resultaat van de optelbewerking de aaneengeschakelde string. Merk op dat we in Java alleen de + (optelling) operator kunnen overbelasten.
Deze operator heeft twee functies:
- Gehele getallen of numerieke waarden toevoegen.
- Tekenreeksen aaneenschakelen
Daarom is de ondersteuning voor overbelasting door operators beperkt in Java, in tegenstelling tot C ++, waarin we bijna alle operators kunnen overbelasten, met uitzondering van een paar zoals sizeof, dot-operator, enz.
Het onderstaande programma demonstreert overbelasting door operators in Java.
Uitgang:
In het bovenstaande programma hebben we de ‘+’ operator overbelast. Wanneer we twee integer-waarden doorgeven aan de overloaded-methode, wordt een som van twee gehele getallen geretourneerd en wanneer twee strings worden doorgegeven, is het resultaat de aaneengeschakelde string.
Bepaalde punten die moeten worden opgemerkt met betrekking tot overbelasting en polymorfisme tijdens het compileren.
- Overbelasting van methoden is de manier om compilatietijdpolymorfisme te implementeren dat ook bekend staat als statisch polymorfisme.
- Statisch polymorfisme is ook bekend als vroege binding of compilatietijdbinding.
- Omdat binding van parameters en functieaanroep plaatsvindt tijdens het compileren, wordt overbelasting compilatietijdbinding genoemd.
- We kunnen alleen de ‘+’ operator in Java overbelasten en het voert de toevoeging van twee gehele getallen of de aaneenschakeling van twee strings uit.
Veel Gestelde Vragen
Vraag 1) Waarom hebben we polymorfisme nodig in Java?
Antwoord: Polymorfisme stelt ons in staat om veel implementaties voor één object te hebben. Door overbelasting van methoden hoeven we niet te veel methoden te hebben met verschillende namen die moeilijk te onthouden zijn. We kunnen in plaats daarvan overbelaste methoden hebben, zodat we een duidelijke implementatie kunnen hebben van de methoden die vergelijkbare functies uitvoeren.
Ook vervangende hulpmiddelen bij de juiste implementatie van overerving waarmee we op een eenvoudigere manier meer functionaliteit aan de bestaande klassen kunnen toevoegen.
Vraag 2) Wat is polymorfisme OOP?
Antwoord: De objectgeoriënteerde programmeerdefinitie van polymorfisme verwijst naar het vermogen van de programmeertalen om één object in verschillende vormen te implementeren. Polymorfisme wordt ook gedefinieerd als het vermogen van een programma om de methoden van de bovenliggende klasse naar de afgeleide klasse te overschrijven om aanvullende functionaliteit te hebben.
V # 3) Kunnen we de hoofdmethode overbelasten en negeren?
Antwoord: Nee. We kunnen de statische hoofdmethode niet negeren. Hoewel we de hoofdmethode kunnen overbelasten, zal JVM nooit de overbelaste hoofdmethode aanroepen. Het beste antwoord is dus om de hoofdmethode niet te overbelasten of te negeren.
V # 4) Kunnen constructeurs overbelast raken?
Antwoord: Ja, we kunnen de constructors in Java op dezelfde manier overbelasten als de Java-methoden. Constructors hebben meestal dezelfde naam maar een ander aantal argumenten.
V # 5) Waarom is Method Overloading nuttig?
Antwoord: We kunnen schone code schrijven met behulp van methode-overbelasting en het wordt ook leesbaar omdat we methoden hebben met dezelfde naam. Dus als we functionaliteit implementeren voor verschillende gegevenstypen, kunnen we de methoden overbelasten en wordt het gemakkelijker om de code te scheiden.
Gevolgtrekking
Polymorfisme in Java betekent dat een object vele vormen kan hebben. Polymorfisme in Java heeft twee typen, namelijk Compile-time polymorfisme en Runtime polymorfisme. Polymorfisme tijdens het compileren gebeurt tijdens het compileren. Compilatietijdpolymorfisme is statisch en wordt geïmplementeerd door overbelasting van de methode en overbelasting door de operator.
Runtime-polymorfisme wordt uitgevoerd tijdens runtime en is dynamisch. Het wordt geïmplementeerd met behulp van methodeoverschrijving.
In deze tutorial hebben we de manieren gezien om overbelasting van methoden te implementeren. We hebben ook de overbelasting van operators in detail besproken. Java ondersteunt alleen de overbelasting van de ‘+’ - operator.
Lees de Easy Java Training Series door.
Aanbevolen literatuur
- Java String bevat () Method Tutorial met voorbeelden
- Java String length () Methode met voorbeelden
- Java substring () -methode - zelfstudie met voorbeelden
- Java Float-zelfstudie met programmeervoorbeelden
- JAVA-zelfstudie voor beginners: 100+ praktische Java-videotutorials
- TreeMap in Java - Tutorial met Java TreeMap-voorbeelden
- Zelfstudie voor Java String | Java String-methoden met voorbeelden
- Java Double - Tutorial met programmeervoorbeelden