Wat is polymorfisme? En waarom het de moeite waard is om te leren

Als je een 4-deurs woon-werkauto kunt besturen, kun je ook een pick-up besturen. Als je een auto met verbrandingsmotor hebt gereden, kun je ook elektrisch rijden.

De vorm en grootte van personenauto's kunnen van de een tot de ander verschillen. De motor die die voertuigen aandrijft, kan ook heel anders zijn. Maar voor de chauffeur maakt het niet uit.

Je stapt gewoon in, riemen vast, start het voertuig, zet hem in de versnelling en rijd. Dat komt omdat auto's, vrachtwagens en bestelwagens zijn polymorf.

Polymorfisme: het afbreken

Laten we eens kijken naar het woord polymorfisme. Je kunt het opsplitsen in poly, morph, en ism.

Poly betekent veel, zoals hoe veelhoek veel hoeken betekent. Bij gebruik als zelfstandig naamwoord, a morph is een variant van een soort. En ism systeem kan betekenen.

Polymorfisme betekent dus eenvoudig een systeem van vele variaties. Dat zegt echter nog steeds niet veel over hoe het wordt gebruikt bij het programmeren. Dat is de volgende.

Als het loopt als een eend... Waarom polymorfe objecten geweldig zijn

Wanneer je in je code een klasse aanmaakt die van een andere klasse erft, bind je de nieuwe klasse aan een contract. Het contract stelt dat elke variabele en functie in de ouder ook in het kind zal zijn.

Elk voertuig heeft een stuur, gas- en rempedalen en een richtingaanwijzer. U hoeft de motorkap niet te openen om auto te rijden. Het enige dat telt is dat het een auto is.

Hetzelfde geldt voor klassen die erven van andere klassen. Hier is een voorbeeld in TypeScript:

klasse Voertuig {
privé _engine: tekenreeks;
privé _banden: aantal;
constructeur (motor: string = "verbranding", banden: aantal = 4) {
deze._engine = motor;
dit._tires = banden;
}
versnellen (snelheid: getal) {
console.log("versnelt met een snelheid van " + snelheid);
}
rem (druk: aantal) {
console.log ("toepassen " + druk + " druk");
}
sla linksaf() {
console.log("links afslaan");
}
draaiRechts() {
console.log("rechts afslaan");
}
}
klasse Auto verlengt Voertuig {
}
klasse Tesla breidt auto uit {
constructeur() {
super("elektrisch");
}
}

In dit voorbeeld is er een Voertuig klas. De Auto klasse erft van de Voertuig klas. En Tesla erft van Auto. Laten we nu een aantal objecten maken en deze bekijken.

laat myCoupe: Auto = nieuw voertuig();
console.log (mijnCoupe);
console.log (mijnCoupe.constructor.naam);
laat mySedan: Voertuig = nieuwe Tesla(); 
console.log (mijnSedan);
console.log (mySedan.constructor.name);
mijnCoupe.turnLeft();
mijnSedan.turnLeft();

Je kunt zien dat we hebben verklaard mijnCoupé een... zijn Auto en mijnSedan een... zijn Voertuig. Toen hebben we geïnstantieerd mijnCoupé als nieuw Voertuig en mijnSedan als nieuw Tesla. als jij bezoek de TypeScript-sandbox en voer de code uit, je zult zien dat het foutloos werkt. En het gedraagt ​​zich zoals je zou verwachten, op basis van het contract.

Met andere woorden, alle voertuigen kunnen linksaf slaan omdat ze het hebben geërfd van de Voertuig klas. De compiler weet dat elk kind van Voertuig akkoord gegaan met het contract. Het gaat er dus van uit dat alles in orde is, ongeacht in welke klassen de objecten zijn getypt of geïnstantieerd.

Dit wordt soms "eendentypen" genoemd. De compiler gaat ervan uit dat als het loopt als een eend en praat als een eend, het net zo goed een eend kan zijn. Dus de compiler maakt zich geen zorgen over de details en behandelt het object gewoon als een eend.

Polymorfisme maakt uw code kogelvrij

Een ander voordeel van het polymorfismecontract is een garantie dat uw code zal werken. Als je al je variabelen sterk hebt getypt en wat elke functie retourneert, weet je dat elk kind altijd overeenkomt met variabelen, functies en typen.

Dat betekent dat je de code in je lessen kunt toevoegen en wijzigen zonder je programma te onderbreken. Elk object dat verwijst naar a Voertuig object krijgt altijd gegevens en functionaliteit die aan de verwachtingen voldoen, ongeacht hoeveel Auto veranderingen.

De code in de functie geeft mogelijk niet de juiste resultaten. Maar dat is een ander soort probleem. Zolang de functie het contract volgt en het verwachte type variabele retourneert, resulteert dit niet in een code-brekende fout.

Polymorfisme is enorm, en hier zijn nog 10 programmeerprincipes die je moet kennen.

Oefen polymorfisme

• Gebruik de sandbox-link hierboven om een Boot klas.
• Instantieer een nieuw bootobject op zo'n manier dat het een Voertuig type, maar ziet er nog steeds uit als een boot.
• Zorg ervoor dat de boot zich nog steeds als een voertuig gedraagt.

Een laatste voorbeeld van polymorfisme

Polymorfisme kan in eerste instantie een lastig concept zijn om te begrijpen. Maar als je het eenmaal doorhebt, heb je een enorme stap gezet om te begrijpen waar objectgeoriënteerd programmeren echt over gaat. Het concept kan echter nog steeds theoretisch lijken. Dus hier is een solide praktijkvoorbeeld om u te helpen zien hoe nuttig het is.

Stel je voor dat je een web-app bouwt die verbinding maakt met een MySQL-database. Dan besluit de baas over te stappen op een PostgreSQL-database. Betekent dit dat u al uw database-aanroepen moet herschrijven?

Nee, dat doet het niet. Als uw app gebruikmaakt van een Toegang tot de gegevens klasse met subklassen die echt met de gegevens rommelen, heb je geluk. De Toegang tot de gegevens class definieert hoe uw app omgaat met gegevens, niet hoe deze samenwerkt met de database.

Je hebt subklassen zoals MySQLA-toegang en PostgresQLAccess die al het vuile werk doen. Maar als uw app alleen heeft Toegang tot de gegevens objecten, kunt u databases verwisselen zonder een enkele regel app-code te herschrijven.

Hoe u uw objectgeoriënteerde code kunt ordenen met overerving

Om objectgeoriënteerd programmeren goed te krijgen, moet u weten over overerving en hoe het codering kan vereenvoudigen en fouten kan verminderen.

Lees volgende

Over de auteur