Polymorfisme en Duck typen in Ruby

Het polymorfisme is een programmeertechniek dat het gebruik van onderdelen van de broncode staat, terwijl de resterende ongewijzigd, tot run-time gedrag te genereren.

Het maken van polymorfe code is een specifieke betekenis in het object-georiënteerd programmeren: het betekent het creëren van een taxonomie van alle klassen die een interface implementeren.

Dus als, bijvoorbeeld, mijn interface definieert een methode "getArea", elke klasse die deze interface implementeren zal een methode "getArea" hebben: dit laat ons toe om polymorfe methoden schrijven, methoden die hun algoritme uitvoering kan veranderen Afhankelijk van het type object dat wordt doorgegeven als een argument.

Polymorfisme in de traditionele OOP talen

In Java - maar hetzelfde geldt voor C + + en een andere taal, Object Oriented (OO) afgerond, zullen we dan de hand het geval van Ruby - bijvoorbeeld:

 -interface IFormaGeometrica







 {



   



 leegte getArea ();







 }









 public class Driehoek implementeert IFormaGeometrica







 {



 



 @ Override



 



 public int getArea ()



 



 {



  



 rendement (* this.base this.altezza) / 2;



 



 }







 }

In dit geval bepalen we de interface IFormaGeometrica waarin staat dat elk object dat "is" een FormaGeometrica getArea zal een methode - zoals de Driehoek klasse, dat is een FormaGeometrica, heeft zijn eigen implementatie van getArea, wat ons toelaat om een programma te schrijven in staat om de oppervlakte van een geometrische vorm te berekenen, of dat nu aanwezig is in de code en dat zal worden geïmplementeerd in de toekomst, zonder dat de originele broncode.

In feite, als ik schrijf een klasse Calculator:

 public final class Calculator







 {





 



 public static void main (String [] args)



 



 {



  



 Collectie vormen <IFormaGeometrica> =



          



 <IFormaGeometrica> New ArrayList ();





  



 forme.add (Driehoek nieuw ());



  



 forme.add (Square nieuw ());



  



 forme.add (Pentagon nieuw ());





  



 voor (IFormaGeometrica g: vorm)



  



 {



   



 System.out.println (g.calcolaArea ());



  



 }



 



 }







 }

Dit kan als input een verzameling van geometrische vormen, op voorwaarde dat elk object in de collectie moet de interface IFormaGeometrica implementeren, en dat heeft in wezen een methode getArea. Dit voorbeeld in Java is puur academisch: in feite, waarschijnlijk in de constructor van iedere klasse, zullen we onder meer inbreng maatregelen van de zijkanten van de geometrische vorm, de schuine, en ga zo maar door.

Het doel is bereikt: we schreven een klasse die kan afdrukken om video van de oppervlakte van een geometrische vorm. Ik herhaal: dit is de code die al is geïmplementeerd (zoals in het geval van de driehoek), dat wordt uitgevoerd in de toekomst.

Niet alleen: als de uitvoering van de berekening van de Driehoek bevatte een bug, ik kan de klasse veranderen zonder de klasse Triangle Calculator herschrijven. Misschien was ingezet op een server die moet opnieuw opstarten elke verandering: in dit geval niet te hebben om de code te veranderen is een groot voordeel. Maar anders dan dat, is het altijd voordelig om de delen van code die "change" te beperken, omdat elke verandering met zich mee brengt potentiële bugs. Omgekeerd is het een goede programmering gewoonte om altijd weet met zekerheid welke delen van de code die ongewijzigd blijven.

Wat gebeurt er 'achter de schermen "is dat de compiler zorgt ervoor dat elk object in de polymorfe code van de belangrijkste methode van de klasse Calculator de interface implementeert. Op deze manier, ze zeggen is een uitdrukking met behulp van de methodologie van het model door contract, "het contract wordt gerespecteerd."

Zo niet, als dat in de "vormen" hebben een object van een klasse die we niet zouden uitvoeren IFormaGeometrica een fout tijdens het compileren, of niet in slagen om het programma uit te voeren, omdat de compiler zou de fout merken.

Het polymorfisme in Ruby

Maar wat gebeurt er in Ruby? En 'mogelijk in Ruby, die niet is samengesteld, maar geïnterpreteerde taal, het schrijven van polymorfe methoden?

Ja, het is zeker mogelijk, maar er is een diepgaand verschil 'filosofische' dan OO talen en samengesteld, die

we kunnen beschrijven. OO programmeren in Java en klassieke, vast te stellen dat een object behoort tot een bepaald type objecten (die implementeert een bepaalde interface) moet uitdrukkelijk bezwaar af te leiden uit een ouder klasse: in principe moet je de technieken van overerving gebruik (erven door een klasse, een abstracte klasse of een interface).

Het zou hetzelfde zijn als zeggen: Om te bepalen of dit is een eend voor me, neem ik zijn DNA en studie in het laboratorium om te zien of het is eend aan.

In Ruby u gebruik maakt van de 'duck-test "(duck-test), uitgevonden door James Riley (zie http://en.wikipedia.org/wiki/Duck_typing ):

als het loopt als een eend en kwaakt als een eend, dan is het een eend.

(Die overigens is wat ieder van ons als hij ziet een eend).

Wat betekent dit? Het betekent dat in Ruby, en meer algemeen in object-oriented scripting talen, evenals Python en Perl, niet nodig om de interface te geven, noch expliciet inheritance relaties tussen de klassen.

De tolk gewoon "vertrouwen" dat de programmeur, de methode stappen wanneer een polymorfe object dat "moeten" op een bepaalde manier, we eigenlijk hebben de extensie.

• <<
• 1
• 2
• >>