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

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

• Poly = many: poligono = multi-faccia, polistirolo = molti stireni ^(a) , poliglotta = molte lingue 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 diverse 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. Sono considerati raramente come oggetti nel solito termine.

Allo stesso modo, tuttavia, una classe come BigDecimalo Rationalo Imaginarypuò fornire tali operazioni, anche se operano su tipi di dati diversi.

L'esempio classico è la Shapeclasse e tutte le classi che possono ereditare da essa (quadrato, cerchio, dodecaedro, poligono irregolare, splat e così via).

Con il polimorfismo, ciascuna 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 necessita 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 Draw()funzione e il codice client potrebbe semplicemente fare:

shape.Draw()

per ottenere il comportamento corretto per qualsiasi forma.

Ciò è in contrasto con il vecchio modo di fare 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 fondamentali da sapere. Ci sono stati molti "proiettili d'argento" durante la mia lunga carriera che in pratica si sono appena estinti, 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 monomero è costituito da carbonio e idrogeno e il polistirene è costituito da gruppi di questo ,.C8H8(C8H8)n

Forse avrei dovuto dichiarare che un polipo era molte occorrenze della lettera panche se, ora che ho dovuto spiegare la battuta, anche questo non sembra neanche divertente.

A volte, dovresti smettere mentre sei dietro :-)

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 nel 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, auto e camion all'elenco.

Successivamente, possiamo scorrere ogni 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.

Dalla comprensione e l'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 condividendo 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 TAGLIO a queste persone

1. Il chirurgo
2. Lo stilista
3. L'attore

Cosa accadrà?

• Il chirurgo avrebbe iniziato a praticare un'incisione.
• L'acconciatore 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.

Quindi la rappresentazione sopra mostra cosa è il 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, l'aria può venire, la luce può venire, la pioggia può venire, 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:

1. Consiglieri militari
2. Consulenti legali
3. Fisici nucleari (come consulenti)
4. Consulenti medici
5. ecc ecc.

Tutti dovrebbero essere responsabili solo di una 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 'la stessa cosa 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 un cambiamento, è 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 alla classe President. La modifica del codice in due posizioni anziché in una può essere pericolosa, poiché è molto più difficile da mantenere.

C'è un approccio migliore?

C'è 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 usare 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 il presidente sa che quando chiede loro di "consigliare" 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, così come 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 - attraverso una classe base o un'interfaccia comune

Questo in effetti è il polimorfismo, in poche parole. Com'è fatto esattamente? Tramite "l'implementazione di un'interfaccia comune" o utilizzando una classe base (ereditarietà), vedere le risposte sopra che descrivono in modo più chiaro questo. (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 tutto sarebbe classi che "implementano un'interfaccia" - chiamata di Ammettiamolo l' IAdvisorinterfaccia che contiene solo un metodo: Advise(). Ma ora stiamo entrando nei dettagli.

Questo 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 entra nella porta di consigliarlo - 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, ciascuno 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 all'esterno. Ciò vale sia per le variabili di istanza nella struttura 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, così come le 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 una classe non può essere 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 sovraccarico del metodo e concetti di prevalenza del metodo .

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

Ognuno di essi ha le proprie funzionalità avanzate e la tecnologia più avanzata coinvolta nel proprio comportamento di movimento.

Ora creiamo un'auto di tipo 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 di auto 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 ha implementato il metodo di spostamento a modo suo.

La sostituzione del metodo è una caratteristica importante per abilitare il polimorfismo. Usando l'override dei metodi, i sottotipi possono cambiare il modo in cui funzionano i metodi disponibili 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();

  }
}

Esempio di 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.

Si noti 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 ciò 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ù:

• Polimorfismo nella programmazione orientata agli oggetti
• Digitare il polimorfismo

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:

Trattare 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 condividerò ...)

http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife

continua a leggere da questa parte:

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

In generale, è la capacità di interfacciare un numero di diversi tipi di oggetti usando la stessa o superficialmente simile API. 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 base o ad una qualsiasi delle sue sottoclassi, l'implementazione corretta è selezionata al volo, quindi questo è polimorfismo di runtime.

• Modelli: una caratteristica di alcuni linguaggi OO in base ai quali una funzione, una classe, ecc. Può essere parametrizzata da un tipo. Ad esempio, è possibile definire una classe di modello "elenco" generica e quindi istanziarla 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.

Il termine polimorfismo deriva da:

poli = molti

morfismo = la capacità di cambiare

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

Un oggetto studente è anche un oggetto persona. Se "guardi" (ad esempio il cast) allo 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, "guardare" lo stesso oggetto da "angolazioni" diverse può darti "prospettive" diverse (cioè proprietà o metodi diversi)

Quindi questa tecnica ti permette di costruire cose che possono essere "guardate" da diverse angolazioni.

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

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 esempio "Fuga e 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()è di eseguire alcune operazioni e viene dato i valori xe ycome input. Per essere polimorfico, f()deve essere in grado di operare con valori di almeno due tipi distinti (ad es. intE double), trovando ed eseguendo il codice di tipo appropriato.

(continua al 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. ES: 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 si utilizza 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 Fractione una classe chiamata ComplexNumber, entrambe potrebbero includere un metodo chiamato display(), ma ognuna di esse implementerebbe quel 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 è usato solo in combinazione con l'eredità; per esempio, forse Fractioned ComplexNumberentrambi implementano una classe astratta chiamata Numberche ha un metodo display(), che Fraction e ComplexNumber sono quindi entrambi obbligati a implementare. Ma non hai bisogno dell'eredità per sfruttare il 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 confidando che la corretta implementazione del metodo essere chiamato. Ad esempio, supponiamo che l'utente scelga il tipo di Numbercreato:

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

In questo caso, display()verrà chiamato il metodo 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.

Il polimorfismo significa letteralmente forme multiple. (o molti moduli): oggetto di 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 tanti. Puoi chiedere come:

È un 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.

per esempio, Shape è un'interfaccia, ha sottotipi Square , Circle , Diamond . 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 un codice come Square s = (Square)shape, e se la forma fosse Circle, otterrai java.lang.ClassCastException, perché Circle non è Square.

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 è stato dichiarato da una classe, tutte le sottoclassi al di sotto di essa (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:

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

Si noti 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. Anche qui viene esplorato il concetto di eredità, in cui 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.

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

Guarda 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, si consideri l'ereditarietà in C ++: la classe B è derivata 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 "Forma" che definisce il numero di lati del tuo oggetto, puoi creare una nuova classe che lo eredita come "Quadrato ". Quando successivamente crei un'istanza di "Quadrato", puoi lanciarla avanti e indietro da "Forma" 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 è dove ho trovato la definizione sopra. Circa 50 minuti nel video, l'istruttore spiega quanto sopra. https://www.youtube.com/watch?v=TMuno5RZNeE

Cos'è il polimorfismo?

Il polimorfismo è la capacità di:

• Richiamare un'operazione su un'istanza di tipo specializzato conoscendo solo il suo tipo generalizzato mentre si chiama il metodo di tipo specializzato e non quello di tipo generalizzato: si tratta di un polimorfismo dinamico .

• Definisci diversi metodi con il nome di salvataggio ma con parametri diversi: è un polimorfismo statico .

Il primo se la definizione storica e il più importante.

A cosa serve il polimorfismo?

Permette di creare una coerenza fortemente tipizzata della gerarchia di classi e di fare alcune cose magiche come la gestione di elenchi di oggetti di tipi diversi senza conoscerne i tipi ma solo uno dei loro tipi principali, nonché i collegamenti ai dati.

Digitazione forte e debole

Campione

Ecco alcune forme come Punto, Linea, Rettangolo e Cerchio con l'operazione Disegna () che non richiede nulla o un parametro per impostare un timeout per cancellarlo.

public class Shape
{
 public virtual void Draw()
 {
   DoNothing();
 }
 public virtual void Draw(int timeout)
 {
   DoNothing();
 }
}

public class Point : Shape
{
 int X, Y;
 public override void Draw()
 {
   DrawThePoint();
 }
}

public class Line : Point
{
 int Xend, Yend;
 public override Draw()
 {
   DrawTheLine();
 }
}

public class Rectangle : Line
{
 public override Draw()
 {
   DrawTheRectangle();
 }
}

var shapes = new List<Shape> { new Point(0,0), new Line(0,0,10,10), new rectangle(50,50,100,100) };

foreach ( var shape in shapes )
  shape.Draw();

Qui la classe Shape e i metodi Shape.Draw () devono essere contrassegnati come astratti.

Non sono per far capire.

spiegazione

Senza polimorfismo, usando abstract-virtual-override, mentre analizza le forme, è solo il metodo Spahe.Draw () che viene chiamato come CLR non sa quale metodo chiamare. Quindi chiama il metodo del tipo su cui agiamo, e qui il tipo è Shape a causa della dichiarazione dell'elenco. Quindi il codice non fa nulla.

Con il polimorfismo, il CLR è in grado di inferire il tipo reale dell'oggetto su cui agiamo usando quella che viene chiamata una tabella virtuale. Quindi chiama il bene metodo e qui chiama Shape.Draw () se Shape is Point chiama Point.Draw (). Quindi il codice disegna le forme.

Altre letture

C # - Polimorfismo (Livello 1)

Polimorfismo in Java (Livello 2)

Polimorfismo (Guida per programmatori C #)

Tabella dei metodi virtuali