Ce este polimorfismul, la ce folosește și cum este aplicat?
Dacă vă gândiți la rădăcinile grecești ale termenului, ar trebui să devină evident.
Așadar, polimorfismul este capacitatea (în programare) de a prezenta aceeași interfață pentru diferite forme de bază (tipuri de date).
De exemplu, în multe limbaje, numerele întregi și cele flotante sunt implicit polimorfe, deoarece se pot face adunări, scăderi, înmulțiri și așa mai departe, indiferent de faptul că tipurile sunt diferite. Ele sunt rareori considerate obiecte în termenul obișnuit.
Dar, în același mod, o clasă precum BigDecimal
sau Rational
sau Imaginary
poate oferi, de asemenea, aceste operații, chiar dacă operează cu tipuri de date diferite.
Exemplul clasic este clasa Shape
și toate clasele care pot moșteni din ea (pătrat, cerc, dodecaedru, poligon neregulat, splat și așa mai departe).
În cazul polimorfismului, fiecare dintre aceste clase va avea date de bază diferite. O formă punctiformă are nevoie doar de două coordonate (presupunând că se află într-un spațiu bidimensional, bineînțeles). Un cerc are nevoie de un centru și o rază. Un pătrat sau un dreptunghi are nevoie de două coordonate pentru colțurile din stânga sus și din dreapta jos și (eventual) de o rotație. Un poligon neregulat are nevoie de o serie de linii.
Făcând clasa responsabilă atât pentru codul său, cât și pentru datele sale, puteți obține polimorfismul. În acest exemplu, fiecare clasă ar avea propria funcție Draw()
, iar codul clientului ar putea face pur și simplu:
shape.Draw()
pentru a obține comportamentul corect pentru orice formă.
Acest lucru este în contrast cu vechiul mod de a face lucrurile, în care codul era separat de date, și ați fi avut funcții cum ar fi drawSquare()
și drawCircle()
.
Orientarea pe obiecte, polimorfismul și moștenirea sunt concepte strâns legate între ele și este esențial să le cunoașteți. Au existat multe "gloanțe de argint" în timpul lungii mele cariere care, practic, s-au stins pur și simplu, dar paradigma OO s-a dovedit a fi una bună. Învățați-o, înțelegeți-o, iubiți-o - vă veți bucura că ați făcut-o :-)
(a) Inițial am scris asta ca o glumă, dar s-a dovedit a fi corectă și, prin urmare, nu atât de amuzantă. Se întâmplă ca stirenul monomer să fie făcut din carbon și hidrogen, C8H8
, iar polistirenul este făcut din grupuri din acesta, (C8H8)n
.
Poate că ar fi trebuit să precizez că un polip este format din mai multe ocurențe ale literei p
, deși, acum că a trebuit să explic gluma, nici măcar asta nu mi se pare amuzant.
Uneori, ar trebui să renunți cât ești în urmă :-)
Polimorfismul este atunci când puteți trata un obiect ca pe o versiune generică a ceva, dar când îl accesați, codul determină ce tip exact este și apelează codul asociat.
Iată un exemplu în C#. Creați patru clase în cadrul unei aplicații de consolă:
public abstract class Vehicle
{
public abstract int Wheels;
}
public class Bicycle : Vehicle
{
public override int Wheels()
{
return 2;
}
}
public class Car : Vehicle
{
public override int Wheels()
{
return 4;
}
}
public class Truck : Vehicle
{
public override int Wheels()
{
return 18;
}
}
Acum creați următoarele în Main() din modulul pentru aplicația de consolă:
public void Main()
{
List<Vehicle> vehicles = new List<Vehicle>();
vehicles.Add(new Bicycle());
vehicles.Add(new Car());
vehicles.Add(new Truck());
foreach (Vehicle v in vehicles)
{
Console.WriteLine(
string.Format("A {0} has {1} wheels.",
v.GetType().Name, v.Wheels));
}
}
În acest exemplu, creăm o listă a clasei de bază Vehicul, care nu știe câte roți are fiecare dintre subclasele sale, dar știe că fiecare subclasă este responsabilă de cunoașterea numărului de roți pe care le are.
Apoi adăugăm la listă o bicicletă, o mașină și un camion.
În continuare, putem parcurge în buclă fiecare vehicul din listă și le putem trata pe toate în mod identic, însă atunci când accesăm proprietatea "Wheels" a fiecărui vehicul, clasa Vehicle deleagă executarea codului respectiv subclasei relevante.
Acest cod se numește polimorfic, deoarece codul exact care este executat este determinat de subclasa la care se face referire la momentul execuției.
Sper că acest lucru vă ajută.
Din Understanding and Applying Polymorphism in PHP, Mulțumiri Steve Guidetti.
Polimorfismul este un cuvânt lung pentru un concept foarte simplu.
Polimorfismul descrie un model în programarea orientată pe obiecte în care clasele au funcționalități diferite, dar împart o interfață comună.
Frumusețea polimorfismului este că codul care lucrează cu diferite clase nu trebuie să știe ce clasă folosește, deoarece toate sunt folosite în același mod. O analogie din lumea reală pentru polimorfism este un buton. Toată lumea știe cum se folosește un buton: pur și simplu se aplică presiune asupra lui. Cu toate acestea, ceea ce "face" un buton depinde de ceea ce este conectat și de contextul în care este utilizat - dar rezultatul nu afectează modul în care este utilizat. Dacă șeful dvs. vă spune să apăsați un buton, aveți deja toate informațiile necesare pentru a îndeplini sarcina respectivă.
În lumea programării, polimorfismul este utilizat pentru a face aplicațiile mai modulare și mai extensibile. În loc de declarații condiționale dezordonate care descriu diferite cursuri de acțiune, creați obiecte interschimbabile pe care le selectați în funcție de nevoile dumneavoastră. Acesta este obiectivul de bază al polimorfismului.
Dacă cineva le spune CUT acestor oameni
Ce se va întâmpla?
Astfel, reprezentarea de mai sus arată ce este polimorfismul (același nume, comportament diferit) în OOP.
Dacă mergeți la un interviu și intervievatorul vă cere să dați/arătați un exemplu real de polimorfism în aceeași cameră în care ne aflăm, să spunem...
Răspuns - Ușă / Ferestre
Vă întrebați cum?
Prin Ușă / Fereastră - poate veni o persoană, poate veni aerul, poate veni lumina, poate veni ploaia, etc.
Pentru a înțelege mai bine și într-un mod simplu am folosit exemplul de mai sus... Dacă aveți nevoie de referință pentru cod urmați răspunsurile de mai sus.
Președintele Statelor Unite folosește polimorfismul. Cum? Ei bine, are mulți consilieri:
Toată lumea ar trebui să fie responsabilă doar de un singur lucru: Exemplu:
Președintele nu este expert în zincare sau în fizică cuantică. El nu știe multe lucruri - dar știe un singur lucru: cum să conducă țara.
Este cam același lucru cu codul: preocupările și responsabilitățile ar trebui să fie separate pentru clasele/persoanele relevante. Altfel, ai avea un președinte care ar ști literalmente tot ce există în lume - întreaga Wikipedia. Imaginați-vă că ați avea întreaga Wikipedia într-o clasă a codului dumneavoastră: ar fi un coșmar de întreținut.
De ce este o idee proastă ca un președinte să știe toate aceste lucruri specifice?
Dacă președintele ar trebui să le spună în mod specific oamenilor ce să facă, asta ar însemna că președintele trebuie să să știe exact ce trebuie să facă. Dacă președintele trebuie să știe el însuși lucruri specifice, asta înseamnă că atunci când trebuie să faci o schimbare, atunci va trebui să o faci în două locuri, nu doar într-unul.
De exemplu, dacă EPA modifică legile privind poluarea, atunci când se întâmplă acest lucru: va trebui să faci o modificare în clasa EPA și, de asemenea, în clasa președintelui. Schimbarea codului în două locuri, în loc de unul singur, poate fi periculoasă - pentru că este mult mai greu de întreținut.
**Există o abordare mai bună?
Există o abordare mai bună: președintele nu trebuie să cunoască specificul a nimic - el poate cere cele mai bune sfaturi, de la persoane însărcinate în mod special cu acele lucruri.
El poate folosi o abordare polimorfă pentru a conduce țara.
Exemplu - de utilizare a unei abordări polimorfe:
Tot ceea ce face președintele este să ceară oamenilor să îl sfătuiască - și asta este ceea ce face de fapt în viața reală - și asta este ceea ce ar trebui să facă un președinte bun. consilierii săi răspund toți în mod diferit, dar cu toții știu ce vrea să spună președintele: Consiliere(). În biroul său intră sute de oameni. De fapt, nu contează cine sunt aceștia. Tot ce știe președintele este că atunci când le cere să "Consilieze", ei știu cum să răspundă în consecință:
public class MisterPresident
{
public void RunTheCountry()
{
// assume the Petraeus and Condi classes etc are instantiated.
petraeus.Advise(); // # Petraeus says send 100,000 troops to Fallujah
condolezza.Advise(); // # she says negotiate trade deal with Iran
healthOfficials.Advise(); // # they say we need to spend $50 billion on ObamaCare
}
}
Această abordare îi permite președintelui să conducă țara literalmente fără să știe nimic despre chestii militare, sau despre sănătate sau diplomație internațională: detaliile sunt lăsate în seama experților. Singurul lucru pe care președintele trebuie să îl știe este următorul: "Advise()".
Ce NU doriți:
public class MisterPresident
{
public void RunTheCountry()
{
// people walk into the Presidents office and he tells them what to do
// depending on who they are.
// Fallujah Advice - Mr Prez tells his military exactly what to do.
petraeus.IncreaseTroopNumbers();
petraeus.ImproveSecurity();
petraeus.PayContractors();
// Condi diplomacy advice - Prez tells Condi how to negotiate
condi.StallNegotiations();
condi.LowBallFigure();
condi.FireDemocraticallyElectedIraqiLeaderBecauseIDontLikeHim();
// Health care
healthOfficial.IncreasePremiums();
healthOfficial.AddPreexistingConditions();
}
}
NU! NU! NU! În scenariul de mai sus, președintele face toată treaba: el știe despre creșterea numărului de trupe și despre condițiile preexistente. Aceasta înseamnă că, dacă politicile din Orientul Mijlociu se schimbă, atunci președintele ar trebui să-și schimbe comenzile, asemenea și clasa Petraeus. Ar trebui să trebuiască să schimbăm doar clasa Petraeus, pentru că președintele nu ar trebui să fie nevoit să se împotmolească în acest gen de detalii. El nu trebuie să știe despre detalii. Tot ce trebuie să știe este că, dacă dă un singur ordin, totul va fi rezolvat. Toate detaliile ar trebui lăsate în seama experților.
Acest lucru îi permite președintelui să facă ceea ce știe să facă cel mai bine: să stabilească politica generală, să arate bine și să joace golf :P.
Acesta este, de fapt, polimorfismul, pe scurt. Cum se realizează mai exact? Prin "implementarea unei interfețe comune" sau prin utilizarea unei clase de bază (moștenire) - a se vedea răspunsurile de mai sus, care detaliază mai clar acest lucru. (Pentru a înțelege mai clar acest concept, trebuie să știți ce este o interfață și va trebui să înțelegeți ce este moștenirea. Fără asta, s-ar putea să vă descurcați greu).
Cu alte cuvinte, Petraeus, Condi și HealthOfficials ar fi toate clase care "implementează o interfață" - să o numim interfața IAdvisor
care conține doar o metodă: Advise()
. Dar acum intrăm în detalii.
Acesta ar fi ideal
public class MisterPresident
{
// You can pass in any advisor: Condi, HealthOfficials,
// Petraeus etc. The president has no idea who it will
// be. But he does know that he can ask them to "advise"
// and that's all Mr Prez cares for.
public void RunTheCountry(IAdvisor governmentOfficer)
{
governmentOfficer.Advise();
}
}
public class USA
{
MisterPresident president;
public USA(MisterPresident president)
{
this.president = president;
}
public void ImplementPolicy()
{
IAdvisor governmentOfficer = getAdvisor(); // Returns an advisor: could be condi, or petraus etc.
president.RunTheCountry(governmentOfficer);
}
}
Tot ceea ce trebuie să știți cu adevărat este următorul lucru:
Sper din tot sufletul să vă ajute. Dacă nu înțelegeți nimic postați un comentariu și voi încerca din nou.
Polimorfismul este abilitatea de a trata o clasă de obiecte ca și cum ar fi clasa părinte.
De exemplu, să presupunem că există o clasă numită Animal și o clasă numită Câine care moștenește din Animal. Polimorfismul este abilitatea de a trata orice obiect Dog ca pe un obiect Animal, astfel:
Dog* dog = new Dog;
Animal* animal = dog;
Polimorfismul:
Acesta este conceptul de programare orientată pe obiecte.Capacitatea de diferite obiecte pentru a răspunde, fiecare în felul său, la mesaje identice se numește polimorfism.
Polimorfismul rezultă din faptul că fiecare clasă trăiește în propriul său nume. Numele atribuite într-o clasă definiție nu intră în conflict cu un nume asignat oriunde în afara ei. Acest lucru este adevărat atât de exemplu variabile într-un obiect date de structura și de obiect metode:
Doar ca domenii de o C structura sunt într-o protejat de nume, deci sunt un obiect variabile de instanta.
Numele de metode sunt, de asemenea, protejate. Spre deosebire de numele de C funcții, metoda de nume nu sunt simboluri globale. Numele unei metode într-o singură clasa nu poate intra în conflict cu numele de metode în alte clase; două foarte clase diferite pot implementa cu nume identic metode.
Nume de metode fac parte din interfata unui obiect. Atunci când un mesaj este trimis solicită un obiect face ceva, mesajul de nume metoda obiectul ar trebui să efectueze. Pentru obiecte diferite pot avea metode cu același nume, sensul unui mesaj trebuie să fie înțeleasă raport cu un anumit obiect care primește mesajul. Același mesaj trimis la două obiecte diferite pot invoca două metode distincte.
Principalul beneficiu de polimorfism este faptul că simplifică interfața de programare. Acesta permite convenții să fie stabilite care pot fi refolosite în clasă după clasă. În loc de a inventa un nou nume pentru fiecare nouă funcție ce adăugați un program, același nume pot fi refolosite. La interfața de programare poate fi descris ca un set de abstract comportamente, destul de în afară de cursurile pe care le pune în aplicare.
Exemple:
Exemplu-1: Aici este un exemplu simplu scris în Python 2.x.
class Animal:
def __init__(self, name): # Constructor of the class
self.name = name
def talk(self): # Abstract method, defined by convention only
raise NotImplementedError("Subclass must implement abstract method")
class Cat(Animal):
def talk(self):
return 'Meow!'
class Dog(Animal):
def talk(self):
return 'Woof! Woof!'
animals = [Cat('Missy'),
Dog('Lassie')]
for animal in animals:
print animal.name + ': ' + animal.talk()
Exemplu-2: Polimorfismul este puse în aplicare în Java folosind metoda supraîncărcarea și metode imperative concepte.
Să ne gândim Masina de exemplu pentru a discuta polimorfism. Ia orice marcă, cum ar fi Ford, Honda, Toyota, BMW, Benz, etc., Totul este de tip Auto.
Dar fiecare au propriile lor caracteristici avansate și tehnologie mai avansată a implicat în mișcarea lor de comportament.
Acum, să ne creăm o bază de tipul de Masina
Car.java
public class Car {
int price;
String name;
String color;
public void move(){
System.out.println("Basic Car move");
}
}
Să ne pună în aplicare Ford Masina de exemplu.
Ford extinde tip de Masina pentru a moșteni toți membrii săi(proprietăți și metode).
Ford.java
public class Ford extends Car{
public void move(){
System.out.println("Moving with V engine");
}
}
Cele de mai sus Ford clasa extinde clasa Auto și, de asemenea, pune în aplicare muta() metodă. Chiar dacă mutarea metoda este deja disponibil pentru Ford prin Moștenire, Ford are încă puse în aplicare metoda în felul său. Aceasta se numește metoda imperative.
Honda.java
public class Honda extends Car{
public void move(){
System.out.println("Move with i-VTEC engine");
}
}
Doar ca Ford, Honda extinde, de asemenea, tipul de Mașină și puse în aplicare mișcare metoda în felul său.
Metoda imperative este o caracteristică importantă pentru a permite Polimorfism. Folosind Metoda imperative, Sub tipuri poate schimba modul în care metodele de lucru care sunt disponibile prin moștenire.
PolymorphismExample.java
public class PolymorphismExample {
public static void main(String[] args) {
Car car = new Car();
Car f = new Ford();
Car h = new Honda();
car.move();
f.move();
h.move();
}
}
Polimorfismul Exemplu De Ieșire:
În PolymorphismExample clasa principala metodă, am creat trei obiecte - Auto, Ford și Honda. Toate cele trei obiecte sunt menționate de tipul de Masina.
Vă rugăm să rețineți că un punct important aici, ca Un super-tip clasa se poate referi la o clasa Sub tip de obiect, dar vice-vers nu este posibilă. Motivul este că toți membrii de super clasa sunt disponibile la subclasa folosind moștenire și în timpul compilării, compilatorul încearcă să evalueze dacă tipul de referință suntem folosind-a metoda, el este încercarea de a accesa.
Astfel, pentru trimiteri masina,f și h în PolymorphismExample, mișcare există o metodă de tipul de Masina. Deci, compilatorul trece procesul de compilare fără probleme.
Dar când e vorba de a alerga timp de executie, mașină virtuală invocă metode pe obiecte care sunt sub-tipuri. Deci, metoda muta() este invocată de lor implementari.
Deci, toate obiectele sunt de tip Mașină, dar în timp a alerga, executarea depinde de Obiectul pe care invocația se întâmplă. Aceasta se numește polimorfism.
De obicei, aceasta se referă la capacitatea unui obiect de tip a să se comporte ca un obiect de tip B. În programarea orientată obiect este de obicei realiza prin moștenire. Unele link-uri wikipedia pentru a citi mai multe:
EDIT: fix link-uri rupte.
Polimorfismul este aceasta:
class Cup {
int capacity
}
class TeaCup : Cup {
string flavour
}
class CoffeeCup : Cup {
string brand
}
Cup c = new CoffeeCup();
public int measure(Cup c) {
return c.capacity
}
puteți trece doar o Ceașcă în loc de o anumită instanță. Acest lucru ajută în generalitatea pentru că tu nu't trebuie să furnizeze o anumită măsură (a) exemplu pe fiecare ceasca de tip
Știu că acest lucru este o mai veche întrebare cu multe răspunsuri, dar am'd dori să includă o sentință răspuns:
Tratarea unui tip derivat ca și cum ar fi l's tipul de bază.
Există o mulțime de exemple de mai sus care arată acest lucru în acțiune, dar eu simt acest lucru este un bun răspuns concis.
(Am fost de navigare pe un alt articol pe ceva cu totul diferit.. și polimorfismul apărut... Acum am crezut că am știut ce Polimorfism a fost.... dar se pare că nu în acest mod frumos de explicat.. a Vrut să-l scrie undeva.. mai bine va împărtăși... )
http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife
citeste pe la partea asta:
..... polimorfism. Ca's studios mod de a spune care diferite substantive pot avea același verb aplicate pentru a le.
În general vorbind, l's capacitatea de a interfața cu un număr de diferite tipuri de obiecte folosind același sau un superficial similare API. Există diferite forme:
Funcția de supraîncărcare: definirea mai multe funcții cu același nume și diferite tipuri de parametri, cum ar fi sqrt(float), sqrt(double) și sqrt(complex). În cele mai multe limbi, care permite acest lucru, compilatorul va selecta automat cel corect pentru tipul de argument fiind trecut în ea, astfel acest lucru este compilare-timp de polimorfism.
Metodele virtuale în OOP: o metodă dintr-o clasă poate avea diverse implementări adaptate la specificul subclasele sale; fiecare dintre acestea este spus pentru a trece peste implementare a dat în clasa de bază. Având un obiect care poate fi din clasa de baza sau la oricare dintre subclasele sale, punerea corectă în aplicare este selectat pe zbor, astfel acest lucru este run-time polimorfism.
Template-uri: o caracteristică a unor OO limbi prin care o funcție, de clasă, etc. poate fi parametrizat de un tip. De exemplu, puteți defini un generic "lista" șablon de clasă, și apoi instantiate ca "listă de numere întregi", "listă de siruri de caractere", poate chiar "listă de liste de siruri de caractere" sau cum ar fi. În general, puteți scrie codul o singură dată pentru o structură de date de arbitrare tip de element, și compilatorul generează versiuni pentru diferite tipuri de elemente.
Termenul de polimorfism vine de la:
poli = multe
morfism = capacitatea de a schimba
În programare, polimorfismul este un "tehnica" care vă permite să "uita" la un obiect ca fiind mai mult decât un singur tip de lucru. De exemplu:
Un obiect student este, de asemenea, o persoană obiect. Dacă aveți "uita" (de exemplu cast) de la elev, probabil poti cere ID-ul de student. Puteți't întotdeauna faci asta cu o persoana, nu? (o persoană nu este neapărat un student, astfel s-ar putea să nu aveți un ID de student). Cu toate acestea, o persoană care, probabil, are un nume. Un student nu prea.
Linia de fund, "uita" la același obiect din diferite "unghiuri" pot da diferite "perspective" (de exemplu, diferite proprietăți sau metode)
Deci această tehnică vă permite să construiască lucruri care pot fi "uitat" cel din unghiuri diferite.
De ce folosim polimorfismul? Pentru inceput ... abstractizare. La acest punct ar trebui să fie suficient de info :)
Polimorfismul este capacitatea de obiect care poate fi luat în mai multe forme. De exemplu, în clasa uman un om poate acționa în mai multe forme, atunci când vorbim despre relatii. EX: UN om este ca un tată pentru fiul său și el este soțul soției sale și el este profesor pentru elevii săi.
Am'am oferit o prezentare generală la nivel înalt de polimorfism pentru o altă întrebare:
https://stackoverflow.com/questions/5854581/polymorphism-in-c/5854862#5854862
Sper că vă ajută. Un extract...
...el ajută pentru a începe de la un simplu test pentru el și definirea [polimorfism]. Ia în considerare cod:
Type1 x;
Type2 y;
f(x);
f(y);
Aici,
f()
este de a efectua o operațiune și este dat de valorile " x " și " y " ca date de intrare. Pentru a fi polimorfe,f()
trebuie să fie capabil să opereze cu valori de cel puțin două tipuri distincte (de exemplu,int
sidouble
), găsirea și executare de tip cod adecvat.
( continuare la https://stackoverflow.com/questions/5854581/polymorphism-in-c/5854862#5854862 )
Polimorfismul este capacitatea unui obiect de a lua multe forme. Cea mai comună utilizare de polimorfism în OOP apare atunci când o clasă părinte referință este folosit pentru a se referi la un copil de clasa object. În acest exemplu, că este scris în Java, avem trei tip de vehicul. Vom crea trei tipuri diferite de obiecte și încearcă să rula lor de roți metoda:
public class PolymorphismExample {
public static abstract class Vehicle
{
public int wheels(){
return 0;
}
}
public static class Bike extends Vehicle
{
@Override
public int wheels()
{
return 2;
}
}
public static class Car extends Vehicle
{
@Override
public int wheels()
{
return 4;
}
}
public static class Truck extends Vehicle
{
@Override
public int wheels()
{
return 18;
}
}
public static void main(String[] args)
{
Vehicle bike = new Bike();
Vehicle car = new Car();
Vehicle truck = new Truck();
System.out.println("Bike has "+bike.wheels()+" wheels");
System.out.println("Car has "+car.wheels()+" wheels");
System.out.println("Truck has "+truck.wheels()+" wheels");
}
}
Rezultatul este:
Pentru mai multe informații vă rugăm să vizitați https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java. Sper că vă ajută.
Las's folosesc o analogie. Pentru un anumit muzicale script fiecare muzician care cântă îi dă propria atinge în interpretare.
Muzician pot fi captate cu interfețe, genul de muzician care face parte poate fi o abstrac clasa care definește unele reguli globale de interpretare și fiecare muzician poate fi modelat cu o clasa de beton.
Dacă sunteți un ascultător de opere muzicale, aveți o referință la script-ul de exemplu, Bach's 'Fuga si Tocata' si fiecare muzician care efectuează o face polymorphicaly în felul ei.
Acesta este doar un exemplu de un posibil design (în Java):
public interface Musician {
public void play(Work work);
}
public interface Work {
public String getScript();
}
public class FugaAndToccata implements Work {
public String getScript() {
return Bach.getFugaAndToccataScript();
}
}
public class AnnHalloway implements Musician {
public void play(Work work) {
// plays in her own style, strict, disciplined
String script = work.getScript()
}
}
public class VictorBorga implements Musician {
public void play(Work work) {
// goofing while playing with superb style
String script = work.getScript()
}
}
public class Listener {
public void main(String[] args) {
Musician musician;
if (args!=null && args.length > 0 && args[0].equals("C")) {
musician = new AnnHalloway();
} else {
musician = new TerryGilliam();
}
musician.play(new FugaAndToccata());
}
Polimorfismul este capacitatea de programator pentru a scrie metode cu același nume, care fac lucruri diferite pentru diferite tipuri de obiecte, în funcție de nevoile de acele obiecte. De exemplu, dacă ați fost în curs de dezvoltare o clasa numita Fracțiune
si o clasa numita ComplexNumber
, ambele ar putea include o metoda numita display()
, dar fiecare dintre ele ar pune în aplicare această metodă în mod diferit. În PHP, de exemplu, ai putea să-l pună în aplicare astfel:
// Class definitions
class Fraction
{
public $numerator;
public $denominator;
public function __construct($n, $d)
{
// In real life, you'd do some type checking, making sure $d != 0, etc.
$this->numerator = $n;
$this->denominator = $d;
}
public function display()
{
echo $this->numerator . '/' . $this->denominator;
}
}
class ComplexNumber
{
public $real;
public $imaginary;
public function __construct($a, $b)
{
$this->real = $a;
$this->imaginary = $b;
}
public function display()
{
echo $this->real . '+' . $this->imaginary . 'i';
}
}
// Main program
$fraction = new Fraction(1, 2);
$complex = new ComplexNumber(1, 2);
echo 'This is a fraction: '
$fraction->display();
echo "\n";
echo 'This is a complex number: '
$complex->display();
echo "\n";
Ieșiri:
This is a fraction: 1/2
This is a complex number: 1 + 2i
Unele dintre alte răspunsuri par să sugereze că polimorfismul este utilizat numai în combinație cu moștenire; de exemplu, poate din Fracțiune " și "ComplexNumber ambele implementa o clasă abstractă numit "Număr", care are o metoda display()
, care Fracțiune și ComplexNumber sunt apoi ambele obligat să pună în aplicare. Dar don't nevoie de moștenire pentru a profita de polimorfism.
Cel puțin în mod dinamic tastat limbi, cum ar fi PHP (eu nu't știu despre C++ sau Java), polimorfismul permite dezvoltator pentru a apela o metodă fără a fi necesar a se cunoaște tipul de obiect înainte de timp, și de încredere că punerea în aplicare corectă a metodei va fi numit. De exemplu, spune utilizatorul alege tipul de "Număr" creat:
$userNumberChoice = $_GET['userNumberChoice'];
switch ($userNumberChoice) {
case 'fraction':
$userNumber = new Fraction(1, 2);
break;
case 'complex':
$userNumber = new ComplexNumber(1, 2);
break;
}
echo "The user's number is: ";
$userNumber->display();
echo "\n";
În acest caz, display()
metoda va fi numit, chiar dacă dezvoltatorul poate't știu înainte de timp, dacă utilizatorul va alege o fracțiune sau un număr complex.
Polimorfismul:
executare Diferite în funcție de instanță a clasei, nu tipul de referință variabilă.
O interfață de tip referință variabilă se poate referi la oricare dintre cazuri de clasă care implementează interfața respectivă.
Polimorfism literal înseamnă, mai multe forme. (sau mai multe forme) : Obiect din clase diferite și de același nume metodă , dar fluxurile de lucru sunt diferite. Un exemplu simplu ar fi:
Ia în considerare o persoană X.
El este o singură persoană, dar el acționează ca multe. Ați putea întreba cum:
El este un fiu pentru mama lui. Un prieten la prietenii lui. Un frate la sora lui.