Inhoudsopgave
Dit is het tweede deel van een reeks tutorials die gericht zijn op het herzien van de basisonderwerpen van de Java-taal om de lezer voor te bereiden op het gebruik van het Spring Framework. Het eerste deel van deze tutorialreeks is hier te vinden. In deze tutorial zullen we het hebben over polymorfisme.Het woord polymorfisme komt van het Griekse "poly" wat veel betekent en "morpho" wat vorm betekent en in het algemeen is dat waar het naar verwijst, het vermogen om meerdere vormen aan te nemen. In Object Oriented Programming hebben we het over variabelen of referenties die de vorm kunnen aannemen van verschillende objecten.
Nu je weet waar het concept vandaan komt, laten we proberen het te relateren aan de Java-taal. Zoals we in de vorige tutorial hebben gezien, stelt het concept van "Overerving" ons in staat om een ouder-kindrelatie tussen 2 privéklassen tot stand te brengen:
In dit voorbeeld is de overervingsrelatie tussen de klasse Hond en de klas Dier, klas Kat en de klas Dier en de klas Paard en de klas Dier, merk op dat tussen Hond, Kat Y Paard er is geen directe relatie.
Als we dit diagram als basis gebruiken, kunnen we zeggen dat een hond een dier IS, een kat een dier en een paard een dier. Als je de relatie op die manier in Java kunt uitdrukken, kunnen we zeggen dat een variabele van de Class Dier is polymorf omdat het de vorm kan aannemen van a Paard, van een Kat of een Hond.
In de vorige tutorial hebben we ook gezien dat ALLE klassen direct of indirect van de klasse erven Object, in dit geval is het diagram iets completer als we het als volgt definiëren:
En dit kan meerdere niveaus naar beneden worden uitgebreid (in wezen hangt de levelcap af van je JVM, maar is normaal gesproken boven de 40) Dus een dier IS een object, een kat IS een dier en een kat (door transitiviteit) IS een object.
Met Java kunt u vervolgens klasseverwijzingen op hoge punten in deze structuur gebruiken om te verwijzen naar objecten eronder in de structuur. Bijvoorbeeld:
public static void main (String [] args) {Object o1 = nieuw object (); Dier a1 = nieuw dier (); Hond p = nieuwe Hond (); o1 = a1; o1 = p; a1 = p; Object o2 = nieuw dier (); Object o3 = nieuwe hond (); Dier a2 = nieuwe hond (); booleaans b1 = o1 == o2; booleaans b2 = o1 == o3; booleaans b3 = o1 == a2; if (b1 || b2 || b3) {Niets doen (); }} Zoals u kunt zien, kan een objectvariabele verwijzen naar een dierlijk object of een hondobject, net zoals een diervariabele naar een hondobject kan verwijzen. De hieruit afgeleide polymorfismecapaciteit leidt ertoe dat we een object kunnen manipuleren zonder dat we precies hoeven te weten welk object IS, laten we de volgende voorbeeldmethode bekijken:
openbare statische leegte doSomething (Animal a) {a.getColorDePelo (); }Wanneer een applicatie deze methode gebruikt, weet het niet welk dier het per parameter ontvangt, het kan een hond zijn, het kan een kat zijn, het kan een paard zijn of later een mol, een olifant, een mandril of een andere klasse die is van het type Dier.
De sleutel tot deze eigenschap is dat het het programma in staat stelt om methoden van bepaalde subklassen te gebruiken zonder specifiek te weten welk type dier het is en zo een aanzienlijk abstractieniveau te behouden met betrekking tot toekomstige implementaties van de klasse Animal.
In de volgende tutorial zullen we dieper ingaan op het onderwerp polymorfisme, we zullen zien wat interfaces zijn en hoe te programmeren gericht op interfaces, wat zal helpen om de volgende tutorials te begrijpen.
Het onderwerp is wat langer geworden dan ik had verwacht, maar wanhoop niet! Het is belangrijk om deze concepten goed te begrijpen voordat u Dependency Injection start om te begrijpen hoe Spring werkt.
Ik hoop dat we week na week doorgaan met deze tutorials, vergeet niet om je opmerkingen achter te laten tot de volgende keer!Vond je deze Tutorial leuk en heb je eraan geholpen?Je kunt de auteur belonen door op deze knop te drukken om hem een positief punt te geven
