Qual è la differenza tra polimorfismo e spedizione multipla?

Question

... o sono la stessa cosa? Ho notato che ognuno ha la sua voce di Wikipedia: Polimorfismo , Invio multiplo , ma ho difficoltà a vedere in che modo differiscono i concetti.

Modifica: e in che modo Overloading si adatta a tutto questo ?

Answer 1

Il polimorfismo è la funzione che consente a un linguaggio / programma di prendere decisioni durante il runtime su quale metodo invocare in base ai tipi dei parametri inviati a quel metodo.

Il numero di parametri utilizzati dal linguaggio / runtime determina il 'tipo' di polimorfismo supportato da un linguaggio.

L'invio singolo è un tipo di polimorfismo in cui viene utilizzato un solo parametro (il destinatario del messaggio - this o self) per determinare la chiamata.

La spedizione multipla è un tipo di polimorfismo in cui in più parametri vengono utilizzati per determinare quale metodo chiamare. In questo caso, il ricevitore così come i tipi dei parametri del metodo vengono utilizzati per indicare quale metodo richiamare.

Quindi puoi dire che il polimorfismo è il termine generale e che l'invio multiplo e singolo sono tipi specifici di polimorfismo.

Addendum: il sovraccarico si verifica durante il tempo di compilazione. Utilizza le informazioni sul tipo disponibili durante la compilazione per determinare quale tipo di metodo chiamare. La spedizione singola / multipla avviene durante il runtime.

Codice di esempio:

using NUnit.Framework;

namespace SanityCheck.UnitTests.StackOverflow
{
    [TestFixture]
    public class DispatchTypes
    {
        [Test]
        public void Polymorphism()
        {
            Baz baz = new Baz();
            Foo foo = new Foo();

            // overloading - parameter type is known during compile time
            Assert.AreEqual("zap object", baz.Zap("hello"));
            Assert.AreEqual("zap foo", baz.Zap(foo));


            // virtual call - single dispatch. Baz is used.
            Zapper zapper = baz;
            Assert.AreEqual("zap object", zapper.Zap("hello"));
            Assert.AreEqual("zap foo", zapper.Zap(foo));


            // C# has doesn't support multiple dispatch so it doesn't
            // know that oFoo is actually of type Foo.
            //
            // In languages with multiple dispatch, the type of oFoo will 
            // also be used in runtime so Baz.Zap(Foo) will be called
            // instead of Baz.Zap(object)
            object oFoo = foo;
            Assert.AreEqual("zap object", zapper.Zap(oFoo));
        }

        public class Zapper
        {
            public virtual string Zap(object o) { return "generic zapper" ; }
            public virtual string Zap(Foo f) { return "generic zapper"; }
        }

        public class Baz : Zapper
        {
            public override string Zap(object o) { return "zap object"; }
            public override string Zap(Foo f) { return "zap foo"; }
        }

        public class Foo { }
    }
}

Answer 2

Con l'invio multiplo, un metodo può avere più argomenti passati e quale implementazione viene utilizzata dipende dal tipo di ogni argomento. L'ordine di valutazione dei tipi dipende dalla lingua. In LISP, controlla ogni tipo dal primo all'ultimo. Le lingue con invio multiplo fanno uso di funzioni generiche, che sono solo dichiarazioni di funzioni e non sono come metodi generici, che utilizzano parametri di tipo.

L'invio multiplo consente di sottotipare il polimorfismo .

L'invio singolo consente anche un tipo più limitato di polimorfismo (usando lo stesso nome di metodo per oggetti che implementano la stessa interfaccia o ereditano la stessa classe di base). È il classico esempio di polimorfismo, in cui hai metodi che sono sovrascritti in sottoclassi.

Oltre a ciò, generici forniscono polimorfismo di tipo parametrico (ovvero, la stessa interfaccia generica da usare con tipi diversi, anche se non sono correlati & # 8212; come List<T>: esso può essere un elenco di qualsiasi tipo e viene utilizzato allo stesso modo indipendentemente).

Answer 3

Non ho mai sentito parlare di Multiple Dispatch prima, ma dopo aver dato un'occhiata alla pagina di Wikipedia sembra che MD sia un tipo di polimorfismo, quando usato con gli argomenti di un metodo.

Il polimorfismo è essenzialmente il concetto che un oggetto può essere visto come qualsiasi tipo che sia la sua base. Quindi se hai un Car e un Truck, entrambi possono essere visti come Vehicle. Ciò significa che puoi chiamare qualsiasi void* metodo per uno dei due.

L'invio multiplo sembra simile, in quanto consente di chiamare metodi con argomenti di più tipi, tuttavia non vedo determinati requisiti nella descrizione. In primo luogo, non sembra richiedere un tipo di base comune (non che potrei immaginare di implementarlo senza Start()) e puoi avere più oggetti coinvolti.

Quindi, invece di chiamare il metodo StartObject(Object C) su ogni oggetto in un elenco (che è un classico esempio di polimorfismo), puoi chiamare un metodo StartObject() definito altrove e codificarlo per controllare il tipo di argomento in fase di esecuzione e gestire in modo appropriato. La differenza qui è che il metodo Car.Start(Key carKey) deve essere integrato nella classe, mentre il metodo Missile.Start(int launchCode) può essere definito al di fuori della classe in modo che i vari oggetti non debbano conformarsi a un'interfaccia.

Questo potrebbe essere utile se il metodo StartObject(theCar) dovesse essere chiamato con argomenti diversi. Forse StartObject(theMissile) vs. <=>

Ma entrambi potrebbero essere chiamati come <=> o <=>

Concetto interessante ...

Answer 4

Il dispacciamento multiplo è più simile al sovraccarico delle funzioni (come visto in Java / C ++), tranne per il fatto che la funzione invocata dipende dal tipo di runtime degli argomenti, non dal loro tipo statico.

Answer 5

se si desidera l'equivalente concettuale di una chiamata al metodo

(obj_1, obj_2, ..., obj_n)->method

per dipendere da ogni tipo specifico nella tupla, quindi si desidera una spedizione multipla. Il polimorfismo corrisponde al caso n = 1 ed è una caratteristica necessaria di OOP.

Answer 6

La spedizione multipla è una specie di polimorfismo. In Java / C # / C ++, esiste il polimorfismo attraverso l'ereditarietà e l'override, ma non si tratta di invio multiplo, che si basa su due o più argomenti (non solo this, come in Java / C # / C ++)

Answer 7

Invio multiplo si basa sul polimorfismo basato. Il tipico polimorfismo riscontrato in C ++, C #, VB.NET, ecc ... usa l'invio singolo - cioè la funzione che viene chiamata dipende solo da una singola istanza di classe. L'invio multiplo si basa su istanze di più classi.