Che cos'è il polimorfismo, a cosa serve e come viene utilizzato?

https://stackoverflow.com/questions/1031273

06-07-2019
|

Domanda

Soluzione

Se pensi alle radici greche del termine, dovrebbe diventare ovvio.

Poly = many: polygon = many-sided, polystyrene = many styrenes ^(a), polyglot = many languages ??e così via.
Morph = cambiamento o forma: morfologia = studio della forma biologica, Morpheus = il dio greco dei sogni in grado di assumere qualsiasi forma.

Quindi il polimorfismo è la capacità (nella programmazione) di presentare la stessa interfaccia per differenti forme sottostanti (tipi di dati).

Ad esempio, in molte lingue, numeri interi e float sono implicitamente polimorfici poiché è possibile aggiungere, sottrarre, moltiplicare e così via, indipendentemente dal fatto che i tipi siano diversi. Raramente sono considerati oggetti nel solito termine.

Ma, allo stesso modo, anche una classe come BigDecimal o Rational o Imaginary può fornire tali operazioni, anche se operano su diversi tipi di dati.

L'esempio classico è la classe Shape e tutte le classi che possono ereditarne (quadrato, cerchio, dodecaedro, poligono irregolare, splat e così via).

Con il polimorfismo, ognuna di queste classi avrà dati sottostanti diversi. Una forma a punti richiede solo due coordinate (supponendo che si trovi in ??uno spazio bidimensionale ovviamente). Un cerchio ha bisogno di un centro e un raggio. Un quadrato o un rettangolo necessita di due coordinate per gli angoli in alto a sinistra e in basso a destra e (possibilmente) una rotazione. Un poligono irregolare ha bisogno di una serie di linee.

Rendendo la classe responsabile del suo codice e dei suoi dati, puoi ottenere il polimorfismo. In questo esempio, ogni classe avrebbe la sua funzione Draw () e il codice client potrebbe semplicemente fare:

shape.Draw()

per ottenere il comportamento corretto per qualsiasi forma.

Questo è in contrasto con il vecchio modo di fare le cose in cui il codice era separato dai dati e avresti avuto funzioni come drawSquare () e drawCircle () .

Orientamento agli oggetti, polimorfismo ed ereditarietà sono tutti concetti strettamente correlati e sono di vitale importanza da conoscere. Ci sono stati molti "proiettili d'argento" durante la mia lunga carriera che in pratica è appena svanita ma il paradigma OO si è rivelato buono. Imparalo, capiscilo, adoralo - sarai contento di averlo fatto :-)

^(a) Inizialmente l'ho scritto come uno scherzo, ma si è rivelato corretto e, quindi, non così divertente. Lo stirene momomer è costituito da carbonio e idrogeno, C₈H₈ , e il polistirene è costituito da gruppi di questo, (C ₈ H ₈) _n .

Forse avrei dovuto dichiarare che un polipo era molte occorrenze della lettera p anche se, ora che ho dovuto spiegare lo scherzo, anche quello non sembra divertente.

A volte, dovresti semplicemente uscire mentre sei dietro :-)

Altri suggerimenti

Il polimorfismo è quando puoi trattare un oggetto come una versione generica di qualcosa, ma quando accedi ad esso, il codice determina quale tipo esatto è e chiama il codice associato.

Ecco un esempio in C #. Crea quattro classi all'interno di un'applicazione console:

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;
    }
}

Ora crea quanto segue in Main () del modulo per l'applicazione console:

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));
    }
}

In questo esempio, creiamo un elenco della classe base Veicolo, che non conosce quante ruote ha ciascuna delle sue sottoclassi, ma sa che ogni sottoclasse è responsabile della conoscenza di quante ruote ha .

Aggiungiamo quindi una bicicletta, un'auto e un camion all'elenco.

Successivamente, possiamo scorrere ciascun veicolo nell'elenco e trattarli tutti in modo identico, tuttavia quando accediamo a ciascuna proprietà di "Ruote" di veicoli, la classe del veicolo delega l'esecuzione di quel codice alla sottoclasse pertinente.

Si dice che questo codice sia polimorfico, poiché il codice esatto che viene eseguito è determinato dalla sottoclasse a cui viene fatto riferimento in fase di esecuzione.

Spero che questo ti aiuti.

Da Comprensione e applicazione del polimorfismo in PHP , grazie Steve Guidetti.

Il polimorfismo è una parola lunga per un concetto molto semplice.

Il polimorfismo descrive uno schema nella programmazione orientata agli oggetti in cui le classi hanno funzionalità diverse mentre condividono un'interfaccia comune.

Il bello del polimorfismo è che il codice che lavora con le diverse classi non ha bisogno di sapere quale classe sta usando poiché sono tutte usate allo stesso modo.   Un'analogia del mondo reale con il polimorfismo è un pulsante. Tutti sanno come usare un pulsante: basta semplicemente esercitare pressione su di esso. Ciò che "fa" un pulsante, tuttavia, dipende da ciò a cui è collegato e dal contesto in cui viene utilizzato, ma il risultato non influisce sul modo in cui viene utilizzato. Se il tuo capo ti dice di premere un pulsante, hai già tutte le informazioni necessarie per eseguire l'attività.

Nel mondo della programmazione, il polimorfismo viene utilizzato per rendere le applicazioni più modulari ed estensibili. Invece di dichiarazioni condizionali disordinate che descrivono diverse linee d'azione, crei oggetti intercambiabili che selezioni in base alle tue esigenze. Questo è l'obiettivo fondamentale del polimorfismo.

Se qualcuno dice CUT a queste persone

Il chirurgo
L'acconciatore
L'attore

Cosa accadrà?

Il chirurgo avrebbe iniziato a praticare un'incisione.
Il parrucchiere avrebbe iniziato a tagliare i capelli a qualcuno.
L'attore smetterebbe bruscamente di recitare fuori dalla scena attuale, in attesa di una guida alla regia.

La rappresentazione sopra mostra ciò che è polimorfismo (stesso nome, comportamento diverso) in OOP.

Se stai per un'intervista e un intervistatore ti chiede di dire / mostrare un esempio dal vivo per il polimorfismo nella stessa stanza in cui siamo seduti, diciamo-

Risposta - Porta / Windows

Ti chiedi come?

Attraverso la porta / finestra: una persona può venire, può venire l'aria, può venire la luce, può venire la pioggia, ecc.

Per capirlo meglio e in modo semplice ho usato l'esempio sopra .. Se hai bisogno di riferimento per il codice segui le risposte sopra.

Spiegazione semplice per analogia

Il presidente degli Stati Uniti impiega il polimorfismo. Come? Bene, ha molti consiglieri:

Consiglieri militari
Consulenti legali
Fisici nucleari (come consulenti)
Consulenti medici
ecc ecc.

Tutti dovrebbero essere responsabili di una sola cosa: esempio:

Il presidente non è un esperto di zincatura o fisica quantistica. Non sa molte cose, ma sa solo una cosa: come gestire il paese.

È un po 'lo stesso con il codice: le preoccupazioni e le responsabilità dovrebbero essere separate dalle classi / persone pertinenti. Altrimenti avresti il ??presidente che sapeva letteralmente tutto nel mondo - l'intera Wikipedia. Immagina di avere l'intera Wikipedia in una classe del tuo codice: sarebbe un incubo da mantenere.

Perché è una cattiva idea per un presidente conoscere tutte queste cose specifiche?

Se il presidente dovesse dire specificamente alla gente cosa fare, ciò significherebbe che il presidente deve sapere esattamente cosa fare. Se il presidente ha bisogno di conoscere da solo cose specifiche, ciò significa che quando è necessario apportare una modifica, è necessario farlo in due punti, non solo uno.

Ad esempio, se l'EPA modifica le leggi sull'inquinamento, quando ciò accade: dovresti apportare una modifica alla classe EPA e anche la classe President. La modifica del codice in due punti anziché in uno può essere pericolosa, poiché è molto più difficile da mantenere.

Esiste un approccio migliore?

Esiste un approccio migliore: il presidente non ha bisogno di conoscere i dettagli di nulla - può chiedere il miglior consiglio, da persone specificamente incaricate di fare quelle cose.

Può usare un approccio polimorfico per gestire il paese.

Esempio - di utilizzo di un approccio polimorfico:

Tutto ciò che il presidente fa è chiedere alle persone di consigliarlo - ed è quello che fa realmente nella vita reale - ed è quello che dovrebbe fare un buon presidente. tutti i suoi consiglieri rispondono in modo diverso, ma tutti sanno cosa intende il presidente: Advise (). Ha centinaia di persone in streaming nel suo ufficio. In realtà non importa chi siano. Tutto ciò che il presidente sa è che quando chiede loro di " Consiglia " sanno come rispondere di conseguenza :

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
    }
}

Questo approccio consente al presidente di gestire il paese letteralmente senza sapere nulla di materiale militare, assistenza sanitaria o diplomazia internazionale: i dettagli sono lasciati agli esperti. L'unica cosa che il presidente deve sapere è questa: " Advise () " ;.

Cosa NON vuoi:

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();
    }
}

NO! NO! NO! Nello scenario sopra, il presidente sta facendo tutto il lavoro: è a conoscenza dell'aumento del numero di truppe e delle condizioni preesistenti. Ciò significa che se cambiano le politiche mediorientali, allora il presidente dovrebbe cambiare i suoi comandi, e anche la classe Petraeus. Dovremmo solo cambiare la classe di Petraeus, perché il Presidente non dovrebbe impantanarsi in quel tipo di dettagli. Non ha bisogno di conoscere i dettagli. Tutto quello che deve sapere è che se fa un ordine, tutto sarà curato. Tutti i dettagli dovrebbero essere lasciati agli esperti.

Ciò consente al presidente di fare ciò che fa meglio: impostare una politica generale, avere un bell'aspetto e giocare a golf: P.

Come viene effettivamente implementato - tramite una classe base o un'interfaccia comune

Questo in effetti è il polimorfismo, in poche parole. Com'è fatto esattamente? Attraverso "l'implementazione di un'interfaccia comune" o utilizzando una classe base (ereditarietà): vedi le risposte sopra che descrivono questo in modo più chiaro. (Per comprendere più chiaramente questo concetto devi sapere cos'è un'interfaccia e dovrai capire cos'è l'eredità. Senza di ciò, potresti avere difficoltà.)

In altre parole, Petraeus, Condi e HealthOfficials sarebbero tutte classi che "implementano un'interfaccia" - chiamiamolo l'interfaccia IAdvisor che contiene solo un metodo: Advise () . Ma ora stiamo entrando nei dettagli.

Sarebbe l'ideale

    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);
        }
    }

Sommario

Tutto quello che devi veramente sapere è questo:

Il presidente non ha bisogno di conoscere i dettagli - quelli sono lasciati agli altri.
Tutto ciò che il presidente deve sapere è chiedere a chi mai entra nella porta di dargli consigli - e sappiamo che sapranno assolutamente cosa fare quando gli verrà chiesto di avvisare (perché sono tutti in realtà, consulenti (o IAdvisors: ))

Spero davvero che ti aiuti. Se non capisci nulla, pubblica un commento e riproverò.

Il polimorfismo è la capacità di trattare una classe di oggetti come se fosse la classe genitore.

Ad esempio, supponiamo che esista una classe chiamata Animal e una classe chiamata Dog che eredita da Animal. Il polimorfismo è la capacità di trattare qualsiasi oggetto Cane come un oggetto Animale in questo modo:

Dog* dog = new Dog;
Animal* animal = dog;

Polimorfismo:

È il concetto di programmazione orientata agli oggetti. La capacità di oggetti diversi di rispondere, ognuno a modo suo, a messaggi identici è chiamata polimorfismo.

Il polimorfismo deriva dal fatto che ogni classe vive nel proprio spazio dei nomi. I nomi assegnati all'interno di una definizione di classe non sono in conflitto con i nomi assegnati ovunque al di fuori di esso. Ciò vale sia per le variabili di istanza nella struttura dei dati di un oggetto sia per i metodi dell'oggetto:

Proprio come i campi di una struttura C si trovano in uno spazio dei nomi protetto, quindi sono variabili di istanza di un oggetto.
Anche i nomi dei metodi sono protetti. A differenza dei nomi delle funzioni C, i nomi dei metodi non sono simboli globali. Il nome di un metodo in uno la classe non può entrare in conflitto con i nomi dei metodi in altre classi; Due classi molto diverse possono implementare metodi identici.

I nomi dei metodi fanno parte dell'interfaccia di un oggetto. Quando viene inviato un messaggio che richiede che un oggetto faccia qualcosa, il messaggio nomina il metodo che l'oggetto deve eseguire. Poiché oggetti diversi possono avere metodi con lo stesso nome, il significato di un messaggio deve essere compreso in relazione al particolare oggetto che riceve il messaggio. Lo stesso messaggio inviato a due oggetti diversi può invocare due metodi distinti.

Il principale vantaggio del polimorfismo è che semplifica l'interfaccia di programmazione. Permette di stabilire convenzioni che possono essere riutilizzate in classe dopo lezione. Invece di inventare un nuovo nome per ogni nuova funzione aggiunta a un programma, è possibile riutilizzare gli stessi nomi. L'interfaccia di programmazione può essere descritta come un insieme di comportamenti astratti, a parte le classi che li implementano.

Esempi:

Esempio-1: Ecco un semplice esempio scritto in 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()

Esempio-2: il polimorfismo è implementato in Java usando il metodo sovraccarico e il metodo sovrascrivendo .

Consideriamo l'esempio di un'auto per discutere del polimorfismo. Prendi qualsiasi marca come Ford, Honda, Toyota, BMW, Benz ecc., Tutto è di tipo Auto.

Ma ognuno ha le proprie funzionalità avanzate e la tecnologia più avanzata coinvolta nel comportamento delle mosse.

Ora creiamo un tipo di auto di base

Car.java

public class Car {

    int price;
    String name;
    String color;

    public void move(){
    System.out.println("Basic Car move");
    }

}

Implementiamo l'esempio Ford Car.

Ford estende il tipo Car per ereditare tutti i suoi membri (proprietà e metodi).

Ford.java

public class Ford extends Car{
  public void move(){
    System.out.println("Moving with V engine");
  }
}

La precedente classe Ford estende la classe Car e implementa anche il metodo move (). Anche se il metodo di spostamento è già disponibile per Ford tramite l'ereditarietà, Ford ha ancora implementato il metodo a modo suo. Questo si chiama override del metodo.

Honda.java

public class Honda extends Car{
  public void move(){
    System.out.println("Move with i-VTEC engine");
  }
}

Proprio come Ford, Honda estende anche il tipo di auto e implementa il metodo di spostamento a modo suo.

La sostituzione del metodo è una caratteristica importante per abilitare il polimorfismo. Usando l'override del metodo, i sottotipi possono cambiare il modo in cui i metodi funzionano tramite l'ereditarietà.

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();

  }
}

Output di esempio del polimorfismo:

Nel metodo principale della classe PolymorphismExample, ho creato tre oggetti: Car, Ford e Honda. Tutti e tre gli oggetti sono indicati dal tipo di automobile.

Notare qui un punto importante che un tipo di superclasse può fare riferimento a un tipo di oggetto di sottoclasse ma il viceversa non è possibile. Il motivo è che tutti i membri della superclasse sono disponibili per la sottoclasse usando l'ereditarietà e durante il tempo di compilazione, il compilatore tenta di valutare se il tipo di riferimento che stiamo usando ha il metodo a cui sta tentando di accedere.

Quindi, per i riferimenti car, f e h nell'Esempio polimorfismo, il metodo di spostamento esiste dal tipo Car. Quindi, il compilatore passa il processo di compilazione senza problemi.

Ma quando si tratta dell'esecuzione in fase di esecuzione, la macchina virtuale invoca i metodi sugli oggetti che sono sottotipi. Pertanto, il metodo move () viene richiamato dalle rispettive implementazioni.

Quindi, tutti gli oggetti sono di tipo Car, ma durante il tempo di esecuzione l'esecuzione dipende dall'oggetto su cui avviene l'invocazione. Questo si chiama polimorfismo.

Di solito si riferisce alla capacità di un oggetto di tipo A di comportarsi come un oggetto di tipo B. Nella programmazione orientata agli oggetti ciò si ottiene di solito per eredità. Alcuni link di Wikipedia per saperne di più:

EDIT: collegamenti interrotti fissi.

Il polimorfismo è questo:

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
}

puoi passare solo una Coppa anziché un'istanza specifica. Questo aiuta in generale perché non è necessario fornire un'istanza misura () specifica per ciascun tipo di tazza

So che questa è una domanda più vecchia con molte buone risposte, ma vorrei includere una risposta di una frase:

Tratta un tipo derivato come se fosse il suo tipo base.

Ci sono molti esempi sopra che mostrano questo in azione, ma ritengo che questa sia una buona risposta concisa.

(Stavo sfogliando un altro articolo su qualcosa di completamente diverso .. e il polimorfismo spuntò ... Ora pensavo di sapere cosa fosse il polimorfismo .... ma apparentemente non in questo modo bellissimo spiegato ... Volevo scriverlo da qualche parte .. meglio ancora lo condivideremo ...)

http: //www.eioba. COM / a / 1htn / come-i-spiegato-rest-to-mia-moglie

continua a leggere da questa parte:

..... polimorfismo. È un modo geniale di dire che nomi diversi possono avere lo stesso verbo applicato a loro.

Il termine polimorfismo deriva da:

poli = molti

morfismo = la capacità di cambiare

Nella programmazione, il polimorfismo è una "tecnica" che ti permette di "guardare" a un oggetto come più di un tipo di cosa. Ad esempio:

Un oggetto studente è anche un oggetto persona. Se " cerca " (ad es. cast) presso lo studente, probabilmente puoi chiedere l'ID studente. Non puoi sempre farlo con una persona, giusto? (una persona non è necessariamente uno studente, quindi potrebbe non avere un ID studente). Tuttavia, una persona probabilmente ha un nome. Anche uno studente.

In conclusione, "guardando" allo stesso oggetto da "angoli" diversi può darti diverse " prospettive " (ovvero proprietà o metodi diversi)

Quindi questa tecnica ti consente di costruire cose che possono essere "quotate" " da diverse angolazioni.

Perché usiamo il polimorfismo? Per cominciare ... astrazione. A questo punto dovrebbero essere sufficienti informazioni :)

In generale, è la capacità di interfacciare un numero di diversi tipi di oggetti usando la stessa o un'API superficialmente simile. Esistono varie forme:

Sovraccarico di funzioni: definizione di più funzioni con lo stesso nome e diversi tipi di parametri, come sqrt (float), sqrt (double) e sqrt (complex). Nella maggior parte delle lingue che lo consentono, il compilatore selezionerà automaticamente quello corretto per il tipo di argomento che gli viene passato, quindi questo è polimorfismo in fase di compilazione.
Metodi virtuali in OOP: un metodo di una classe può avere varie implementazioni su misura per le specifiche delle sue sottoclassi; si dice che ciascuno di questi ha la precedenza sull'implementazione fornita nella classe base. Dato un oggetto che può appartenere alla classe di base o ad una delle sue sottoclassi, l'implementazione corretta viene selezionata al volo, quindi si tratta di polimorfismo di runtime.
Modelli: una caratteristica di alcuni linguaggi OO per cui una funzione, classe, ecc. può essere parametrizzata da un tipo. Ad esempio, puoi definire un " list " generico classe di modello e quindi istanziarlo come "elenco di numeri interi", "elenco di stringhe", forse anche "elenco di elenchi di stringhe" o simili. Generalmente, si scrive il codice una volta per una struttura di dati di tipo di elemento arbitrario e il compilatore ne genera versioni per i vari tipi di elementi.

Usiamo un'analogia. Per una determinata sceneggiatura musicale ogni musicista che la interpreta dà il proprio tocco nell'interpretazione.

Il musicista può essere astratto con interfacce, il genere a cui appartiene il musicista può essere una classe abstrac che definisce alcune regole di interpretazione globali e ogni musicista che suona può essere modellato con una classe concreta.

Se sei un ascoltatore del lavoro musicale, hai un riferimento alla sceneggiatura, ad es. "Fuga and Tocata" di Bach e ogni musicista che lo esegue lo fa polimorficamente a modo suo.

Questo è solo un esempio di una possibile progettazione (in 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());
}

Ho fornito una panoramica di alto livello del polimorfismo per un'altra domanda:

Polimorfismo in c ++

Spero che sia d'aiuto. Un estratto ...

... aiuta a partire da un semplice test e dalla definizione di [polimorfismo]. Considera il codice:

Type1 x;
Type2 y;

f(x);
f(y);

Qui, f () è per eseguire alcune operazioni e gli vengono dati i valori x e y come input. Per essere polimorfico, f () deve essere in grado di operare con valori di almeno due tipi distinti (ad esempio int e double ), trovando e esecuzione del codice appropriato al tipo.

(continua su Polimorfismo in c ++ )

Il polimorfismo è un'abilità dell'oggetto che può essere assunta in molte forme. Ad esempio, nella classe umana un uomo può agire in molte forme quando parliamo di relazioni. EX: Un uomo è un padre per suo figlio ed è marito per sua moglie ed è insegnante per i suoi studenti.

Il polimorfismo è la capacità di un oggetto di assumere molte forme. L'uso più comune del polimorfismo in OOP si verifica quando viene utilizzato un riferimento di classe genitore per fare riferimento a un oggetto di classe figlio. In questo esempio scritto in Java, abbiamo tre tipi di veicoli. Creiamo tre diversi oggetti e proviamo a eseguire il loro metodo ruote:

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");
    }

}

Il risultato è:

Per ulteriori informazioni, visitare https: // github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java . Spero possa essere d'aiuto.

Il polimorfismo è la capacità del programmatore di scrivere metodi con lo stesso nome che fanno cose diverse per diversi tipi di oggetti, a seconda delle esigenze di tali oggetti. Ad esempio, se stavi sviluppando una classe chiamata Fraction e una classe chiamata ComplexNumber , entrambe potrebbero includere un metodo chiamato display () , ma ognuno implementerebbe questo metodo in modo diverso. In PHP, ad esempio, potresti implementarlo in questo modo:

//  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";

Uscite:

This is a fraction: 1/2
This is a complex number: 1 + 2i

Alcune delle altre risposte sembrano implicare che il polimorfismo sia usato solo in combinazione con l'eredità; ad esempio, forse Fraction e ComplexNumber implementano entrambi una classe astratta chiamata Number che ha un metodo display () , quale Fraction e ComplexNumber sono entrambi obbligati ad attuare. Ma non hai bisogno di l'ereditarietà per trarre vantaggio dal polimorfismo.

Almeno in linguaggi tipicamente dinamici come PHP (non conosco C ++ o Java), il polimorfismo consente allo sviluppatore di chiamare un metodo senza necessariamente conoscere il tipo di oggetto in anticipo e fidarsi che la corretta implementazione di il metodo verrà chiamato. Ad esempio, supponiamo che l'utente scelga il tipo di Number creato:

$userNumberChoice =  Il polimorfismo è la capacità del programmatore di scrivere metodi con lo stesso nome che fanno cose diverse per diversi tipi di oggetti, a seconda delle esigenze di tali oggetti. Ad esempio, se stavi sviluppando una classe chiamata  Fraction  e una classe chiamata  ComplexNumber , entrambe potrebbero includere un metodo chiamato  display () , ma ognuno implementerebbe questo metodo in modo diverso. In PHP, ad esempio, potresti implementarlo in questo modo: 

//  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";


 Uscite: 

This is a fraction: 1/2
This is a complex number: 1 + 2i


 Alcune delle altre risposte sembrano implicare che il polimorfismo sia usato solo in combinazione con l'eredità; ad esempio, forse  Fraction  e  ComplexNumber  implementano entrambi una classe astratta chiamata  Number  che ha un metodo  display () , quale Fraction e ComplexNumber sono entrambi obbligati ad attuare. Ma non  hai bisogno di  l'ereditarietà per trarre vantaggio dal polimorfismo. 

 Almeno in linguaggi tipicamente dinamici come PHP (non conosco C ++ o Java), il polimorfismo consente allo sviluppatore di chiamare un metodo senza necessariamente conoscere il tipo di oggetto in anticipo e fidarsi che la corretta implementazione di il metodo verrà chiamato. Ad esempio, supponiamo che l'utente scelga il tipo di  Number  creato: 

<*>

 In questo caso, verrà chiamato il metodo  display ()  appropriato, anche se lo sviluppatore non può sapere in anticipo se l'utente sceglierà una frazione o un numero complesso. 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";

In questo caso, verrà chiamato il metodo display () appropriato, anche se lo sviluppatore non può sapere in anticipo se l'utente sceglierà una frazione o un numero complesso.

Nella programmazione orientata agli oggetti, il polimorfismo si riferisce alla capacità di un linguaggio di programmazione di elaborare oggetti in modo diverso a seconda del tipo di dati o della classe . Più specificamente, è la capacità di ridefinire i metodi per le classi derivate.

Polimorfismo significa letteralmente forme multiple. (o molte forme): Oggetto da classi diverse e metodo con lo stesso nome, ma i flussi di lavoro sono diversi. Un semplice esempio potrebbe essere:

Considera una persona X.

È solo una persona ma agisce come molti. Puoi chiedere come:

È figlio di sua madre. Un amico per i suoi amici. Un fratello per sua sorella.

Il polimorfismo in OOP significa che una classe potrebbe avere diversi tipi, l'ereditarietà è un modo per implementare il polimorfismo.

ad esempio, Forma è un'interfaccia, ha i sottotipi Quadrato , Cerchio , Diamante . ora hai un oggetto quadrato, puoi eseguire l'upgrade automatico di Square a Shape, perché Square è una forma. Ma quando si tenta di eseguire il downcasting di Shape to Square, è necessario eseguire il cast di tipo esplicito, poiché non si può dire che Shape sia Square, potrebbe anche essere Circle. quindi devi lanciarlo manualmente con codice come Square s = (Square) shape , e se la forma è Circle, otterrai java.lang.ClassCastException , perché Circle è non quadrato.

Polimorfismo:

Esecuzione diversa in base all'istanza della classe, non al tipo di variabile di riferimento.

Una variabile di riferimento del tipo di interfaccia può fare riferimento a qualsiasi istanza di classe che implementa tale interfaccia.

Il polimorfismo è la capacità di usare un oggetto in una data classe, in cui tutti i componenti che compongono l'oggetto sono ereditati da sottoclassi di una determinata classe. Ciò significa che una volta che questo oggetto viene dichiarato da una classe, tutte le sottoclassi sottostanti (e le loro sottoclassi e così via fino a raggiungere la sottoclasse più lontana / più bassa) ereditano l'oggetto e i suoi componenti (trucco).

Ricorda che ogni classe deve essere salvata in file separati.

Il seguente codice esemplifica il polimorfismo:

SuperClass:

public class Parent {
    //Define things that all classes share
    String maidenName;
    String familyTree;

    //Give the top class a default method
    public void speak(){
         System.out.println("We are all Parents");
    }
}

Il padre, una sottoclasse:

public class Father extends Parent{
    //Can use maidenName and familyTree here
    String name="Joe";
    String called="dad";

    //Give the top class a default method
    public void speak(){
        System.out.println("I am "+name+", the father.");
    }
}

Il bambino, un'altra sottoclasse:

public class Child extends Father {
    //Can use maidenName, familyTree, called and name here

    //Give the top class a default method
    public void speak(){
        System.out.println("Hi "+called+". What are we going to do today?");
    }
}

Il metodo di esecuzione, fa riferimento alla classe Parent per iniziare:

public class Parenting{
    public static void main(String[] args) {
        Parent parents = new Parent();
        Parent parent = new Father();
        Parent child = new Child();

        parents.speak();
        parent.speak();
        child.speak();
    }
}

Nota che ogni classe deve essere dichiarata in file * .java separati. Il codice dovrebbe essere compilato. Si noti inoltre che è possibile utilizzare continuamente maidenName e familyTree più in basso. Questo è il concetto di polimorfismo. Il concetto di eredità viene anche esplorato qui, dove una classe è può essere utilizzata o è ulteriormente definita da una sottoclasse.

Spero che questo aiuti e lo chiarisca. Pubblicherò i risultati quando troverò un computer che posso usare per verificare il codice. Grazie per la pazienza!

Il polimorfismo consente alla stessa routine (funzione, metodo) di agire su tipi diversi.

Poiché molte risposte esistenti stanno fondendo il sottotipo con il polimorfismo, qui ci sono tre modi (incluso il sottotipo) per implementare il polimorfismo.

Polimorfismo parametrico (generico) consente a una routine di accettare uno o più parametri di tipo, oltre ai parametri normali, e si esegue su quei tipi.
Polimorfismo di sottotipo consente a una routine di agire su qualsiasi sottotipo dei suoi parametri.
Polimorfismo ad hoc utilizza generalmente un sovraccarico di routine per garantire un comportamento polimorfico, ma può riferirsi anche ad altre implementazioni di polimorfismo.

Vedi anche:

http://wiki.c2.com/?CategoryPolymorphism

https://en.wikipedia.org/wiki/Polymorphism_(computer_science)

Nei linguaggi orientati agli oggetti, il polimorfismo consente il trattamento e la gestione di diversi tipi di dati attraverso la stessa interfaccia. Ad esempio, considera l'ereditarietà in C ++: La classe B deriva dalla classe A. Un puntatore di tipo A * (puntatore alla classe A) può essere utilizzato per gestire sia un oggetto di classe A che un oggetto di classe B.

Il polimorfismo in termini di codifica è quando il tuo oggetto può esistere come tipi multipli attraverso l'ereditarietà ecc. Se crei una classe denominata " Shape " che definisce il numero di lati del tuo oggetto, puoi quindi creare una nuova classe che lo eredita come "Quadrato". Quando successivamente crei un'istanza di "Square" puoi quindi lanciarlo avanti e indietro da " Shape " a "Quadrato" come richiesto.

Il polimorfismo ti dà la possibilità di creare un modulo chiamandone un altro, e tuttavia avere il punto di dipendenza del tempo di compilazione contro il flusso di controllo anziché con il flusso di controllo.

Utilizzando il polimorfismo, un modulo di alto livello non dipende dal modulo di basso livello. Entrambi dipendono dalle astrazioni. Questo ci aiuta ad applicare il principio di inversione di dipendenza ( https://en.wikipedia.org/wiki/Dependency_inversion_principle ).

Qui ho trovato la definizione sopra. Circa 50 minuti nel video, l'istruttore spiega quanto sopra. https://www.youtube.com/watch?v=TMuno5RZNeE

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow