Qu'est-ce que le polymorphisme, à quoi sert-il et comment est-il utilisé?

Si vous pensez aux racines grecques du terme, cela devrait devenir évident.

• Poly = plusieurs: polygone = plusieurs côtés, polystyrène = plusieurs styrènes ^(a) , polyglotte = plusieurs langues, etc.
• Morph = changement ou forme: morphologie = étude de la forme biologique, Morpheus = le dieu grec des rêves capable de prendre n'importe quelle forme.

Le polymorphisme est donc la capacité (en programmation) de présenter la même interface pour différentes formes sous-jacentes (types de données).

Par exemple, dans de nombreux langages, les entiers et les flottants sont implicitement polymorphes puisque vous pouvez ajouter, soustraire, multiplier et ainsi de suite, indépendamment du fait que les types sont différents. Ils sont rarement considérés comme des objets dans le terme habituel.

Mais, de la même manière, une classe comme BigDecimalou Rationalou Imaginarypeut également fournir ces opérations, même si elles opèrent sur différents types de données.

L'exemple classique est la Shapeclasse et toutes les classes qui peuvent en hériter (carré, cercle, dodécaèdre, polygone irrégulier, splat, etc.).

Avec le polymorphisme, chacune de ces classes aura des données sous-jacentes différentes. Une forme ponctuelle n'a besoin que de deux coordonnées (en supposant bien sûr qu'elle soit dans un espace à deux dimensions). Un cercle a besoin d'un centre et d'un rayon. Un carré ou un rectangle a besoin de deux coordonnées pour les coins supérieur gauche et inférieur droit et (éventuellement) d'une rotation. Un polygone irrégulier a besoin d'une série de lignes.

En rendant la classe responsable de son code ainsi que de ses données, vous pouvez obtenir un polymorphisme. Dans cet exemple, chaque classe aurait sa propre Draw()fonction et le code client pourrait simplement faire:

shape.Draw()

pour obtenir le comportement correct pour n'importe quelle forme.

Cela contraste avec l'ancienne façon de faire les choses dans laquelle le code était séparé des données, et vous auriez eu des fonctions telles que drawSquare()et drawCircle().

L'orientation des objets, le polymorphisme et l'héritage sont tous des concepts étroitement liés et ils sont essentiels à connaître. Il y a eu beaucoup de "balles d'argent" au cours de ma longue carrière qui ont simplement échoué, mais le paradigme OO s'est avéré être bon. Apprenez-le, comprenez-le, aimez-le - vous serez content de l'avoir fait :-)

^(a) J'ai écrit cela à l'origine comme une blague, mais cela s'est avéré correct et, par conséquent, pas si drôle. Le monomère styrène se trouve être fabriqué à partir de carbone et d'hydrogène , et le polystyrène est fabriqué à partir de groupes de cela , .C8H8(C8H8)n

J'aurais peut-être dû dire qu'un polype était à plusieurs reprises dans la lettre pbien que, maintenant que j'ai dû expliquer la blague, même cela ne semble pas drôle non plus.

Parfois, vous devez simplement quitter pendant que vous êtes derrière :-)

Le polymorphisme est lorsque vous pouvez traiter un objet comme une version générique de quelque chose, mais lorsque vous y accédez, le code détermine de quel type exact il s'agit et appelle le code associé.

Voici un exemple en C #. Créez quatre classes dans une application 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;
    }
}

Créez maintenant ce qui suit dans le Main () du module pour l'application 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));
    }
}

Dans cet exemple, nous créons une liste de la classe de base Véhicule, qui ne sait pas combien de roues chacune de ses sous-classes possède, mais sait que chaque sous-classe est responsable de savoir combien de roues elle possède.

Nous ajoutons ensuite un vélo, une voiture et un camion à la liste.

Ensuite, nous pouvons parcourir chaque véhicule de la liste et les traiter tous de manière identique, mais lorsque nous accédons à la propriété Wheels de chaque véhicule, la classe Vehicle délègue l'exécution de ce code à la sous-classe appropriée.

Ce code est dit polymorphe, car le code exact qui est exécuté est déterminé par la sous-classe référencée au moment de l'exécution.

J'espère que cela vous aide.

De Comprendre et appliquer le polymorphisme en PHP , merci Steve Guidetti.

Le polymorphisme est un mot long pour un concept très simple.

Le polymorphisme décrit un modèle de programmation orientée objet dans lequel les classes ont des fonctionnalités différentes tout en partageant une interface commune.

La beauté du polymorphisme est que le code travaillant avec les différentes classes n'a pas besoin de savoir quelle classe il utilise car elles sont toutes utilisées de la même manière. Une analogie réelle avec le polymorphisme est un bouton. Tout le monde sait utiliser un bouton: il suffit de lui appliquer une pression. Cependant, ce qu'un bouton «fait» dépend de ce à quoi il est connecté et du contexte dans lequel il est utilisé - mais le résultat n'affecte pas la façon dont il est utilisé. Si votre patron vous dit d'appuyer sur un bouton, vous disposez déjà de toutes les informations nécessaires pour effectuer la tâche.

Dans le monde de la programmation, le polymorphisme est utilisé pour rendre les applications plus modulaires et extensibles. Au lieu d'instructions conditionnelles désordonnées décrivant différents modes d'action, vous créez des objets interchangeables que vous sélectionnez en fonction de vos besoins. Tel est l'objectif fondamental du polymorphisme.

Si quelqu'un dit CUT à ces gens

1. Le chirurgien
2. Le coiffeur
3. L'acteur

Que va-t-il se passer?

• Le chirurgien allait commencer à faire une incision.
• Le coiffeur commençait à couper les cheveux de quelqu'un.
• L'acteur cesserait brusquement d'agir hors de la scène actuelle, en attendant les conseils de la direction.

La représentation ci-dessus montre ce qu'est le polymorphisme (même nom, comportement différent) dans la POO.

Si vous allez pour une interview et que l'intervieweur vous demande de dire / montrer un exemple en direct de polymorphisme dans la même pièce où nous sommes assis, dites-

Réponse - Porte / Fenêtres

Vous vous demandez comment?

Par la porte / fenêtre - une personne peut venir, l'air peut venir, la lumière peut venir, la pluie peut venir, etc.

Pour mieux le comprendre et de manière simple, j'ai utilisé l'exemple ci-dessus. Si vous avez besoin d'une référence pour le code, suivez les réponses ci-dessus.

Explication simple par analogie

Le président des États-Unis emploie le polymorphisme. Comment? Eh bien, il a de nombreux conseillers:

1. Conseillers militaires
2. Conseillers juridiques
3. Physiciens nucléaires (en tant que conseillers)
4. Conseillers médicaux
5. etc.

Tout le monde ne devrait être responsable que d'une chose: Exemple:

Le président n'est pas un expert en revêtement de zinc ou en physique quantique. Il ne sait pas beaucoup de choses - mais il ne sait qu'une chose: comment diriger le pays.

C'est un peu la même chose avec le code: les préoccupations et les responsabilités doivent être séparées pour les classes / personnes concernées. Sinon, vous auriez le président sachant littéralement tout dans le monde - l'ensemble de Wikipedia. Imaginez avoir tout le wikipedia dans une classe de votre code: ce serait un cauchemar à maintenir.

Pourquoi est-ce une mauvaise idée pour un président de connaître toutes ces choses spécifiques?

Si le président devait spécifiquement dire aux gens quoi faire, cela signifierait que le président doit savoir exactement quoi faire. Si le président a besoin de connaître des choses spécifiques lui-même, cela signifie que lorsque vous devez effectuer un changement, vous devrez le faire à deux endroits, pas à un seul.

Par exemple, si l'EPA modifie les lois sur la pollution, alors quand cela se produit: vous devez modifier la classe EPA et également la classe President. Changer le code à deux endroits plutôt qu'à un seul peut être dangereux - car il est beaucoup plus difficile à maintenir.

Est-ce qu'il y a une meilleure approche?

Il y a une meilleure approche: le président n'a pas besoin de connaître les détails de quoi que ce soit - il peut exiger les meilleurs conseils de personnes spécifiquement chargées de faire ces choses.

Il peut utiliser une approche polymorphe pour diriger le pays.

Exemple - d'utilisation d'une approche polymorphe:

Tout ce que le président fait, c'est demander aux gens de le conseiller - et c'est ce qu'il fait réellement dans la vie réelle - et c'est ce qu'un bon président devrait faire. ses conseillers réagissent tous différemment, mais ils savent tous ce que le président entend par: Conseiller (). Il a des centaines de personnes qui entrent dans son bureau. Peu importe qui ils sont. Tout ce que le président sait, c'est que lorsqu'il leur demande de "conseiller", ils savent comment réagir en conséquence :

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

Cette approche permet au président de diriger le pays littéralement sans rien savoir des affaires militaires, des soins de santé ou de la diplomatie internationale: les détails sont laissés aux experts. La seule chose que le président doit savoir est la suivante: "Advise ()".

Ce que vous ne voulez pas:

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

NON! NON! NON! Dans le scénario ci-dessus, le président fait tout le travail: il connaît l'augmentation du nombre de troupes et les conditions préexistantes. Cela signifie que si les politiques du Moyen-Orient changent, le président devra alors changer ses commandes, ainsi que la classe Petraeus. Nous devrions seulement avoir à changer la classe Petraeus, parce que le président ne devrait pas avoir à s'enliser dans ce genre de détails. Il n'a pas besoin de connaître les détails. Tout ce qu'il doit savoir, c'est que s'il passe une commande, tout sera pris en charge. Tous les détails doivent être laissés aux experts.

Cela permet au président de faire ce qu'il fait le mieux: définir la politique générale, bien paraître et jouer au golf: P.

Comment est-il réellement implémenté - via une classe de base ou une interface commune

En fait, c'est le polymorphisme, en bref. Comment cela se fait-il exactement? En "implémentant une interface commune" ou en utilisant une classe de base (héritage) - voir les réponses ci-dessus qui détaillent cela plus clairement. (Pour mieux comprendre ce concept, vous devez savoir ce qu'est une interface et vous devez comprendre ce qu'est l'héritage. Sans cela, vous pourriez avoir du mal.)

En d' autres termes, le général Petraeus, Condi et HealthOfficials seraient toutes les classes qui « mettent en œuvre une interface » - l'appel de let il l' IAdvisorinterface qui contient une seule méthode: Advise(). Mais maintenant, nous entrons dans les détails.

Ce serait idéal

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

Sommaire

Tout ce que vous devez vraiment savoir, c'est ceci:

• Le président n'a pas besoin de connaître les détails - ceux-ci sont laissés à d'autres.
• Tout ce que le président a besoin de savoir, c'est de demander qui a déjà franchi la porte pour le conseiller - et nous savons qu'ils sauront absolument quoi faire quand on leur demandera de conseiller (car ils sont tous en réalité des conseillers (ou des conseillers :))

J'espère vraiment que cela vous aidera. Si vous ne comprenez rien, postez un commentaire et je vais réessayer.

Le polymorphisme est la capacité de traiter une classe d'objets comme s'il s'agissait de la classe parente.

Par exemple, supposons qu'il existe une classe appelée Animal et une classe appelée Dog qui hérite d'Animal. Le polymorphisme est la capacité de traiter n'importe quel objet chien comme un objet animal comme ceci:

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

Polymorphisme:

C'est le concept de la programmation orientée objet. La capacité de différents objets à répondre, chacun à sa manière, à des messages identiques s'appelle le polymorphisme.

Le polymorphisme résulte du fait que chaque classe vit dans son propre espace de noms. Les noms attribués dans une définition de classe n'entrent pas en conflit avec les noms attribués à l'extérieur de celle-ci. Cela est vrai à la fois des variables d'instance dans la structure de données d'un objet et des méthodes de l'objet:

• Tout comme les champs d'une structure C se trouvent dans un espace de noms protégé, les variables d'instance d'un objet le sont également.

• Les noms de méthode sont également protégés. Contrairement aux noms des fonctions C, les noms de méthode ne sont pas des symboles globaux. Le nom d'une méthode dans une classe ne peut pas entrer en conflit avec les noms de méthode dans d'autres classes; deux classes très différentes peuvent implémenter des méthodes nommées de manière identique.

Les noms de méthode font partie de l'interface d'un objet. Lorsqu'un message est envoyé demandant qu'un objet fasse quelque chose, le message nomme la méthode que l'objet doit exécuter. Étant donné que différents objets peuvent avoir des méthodes portant le même nom, la signification d'un message doit être comprise par rapport à l'objet particulier qui reçoit le message. Le même message envoyé à deux objets différents peut invoquer deux méthodes distinctes.

Le principal avantage du polymorphisme est qu'il simplifie l'interface de programmation. Il permet d'établir des conventions qui peuvent être réutilisées classe après classe. Au lieu d'inventer un nouveau nom pour chaque nouvelle fonction que vous ajoutez à un programme, les mêmes noms peuvent être réutilisés. L'interface de programmation peut être décrite comme un ensemble de comportements abstraits, indépendamment des classes qui les implémentent.

Exemples:

Exemple 1: Voici un exemple simple , écrit en 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()

Exemple 2: le polymorphisme est implémenté en Java à l' aide de la surcharge de méthode et des concepts de substitution de méthode .

Prenons l'exemple de Car pour discuter du polymorphisme. Prenez n'importe quelle marque comme Ford, Honda, Toyota, BMW, Benz etc., tout est de type voiture.

Mais chacun a ses propres fonctionnalités avancées et une technologie plus avancée impliquées dans son comportement de déplacement.

Créons maintenant une voiture de base

Car.java

public class Car {

    int price;
    String name;
    String color;

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

}

Implémentons l'exemple de Ford Car.

Ford étend le type Car pour hériter de tous ses membres (propriétés et méthodes).

Ford.java

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

La classe Ford ci-dessus étend la classe Car et implémente également la méthode move (). Même si la méthode de déplacement est déjà disponible pour Ford via l'héritage, Ford a toujours mis en œuvre la méthode à sa manière. C'est ce qu'on appelle la substitution de méthode.

Honda.java

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

Tout comme Ford, Honda étend également le type de voiture et a mis en œuvre la méthode de déplacement à sa manière.

La substitution de méthode est une caractéristique importante pour activer le polymorphisme. À l'aide de la substitution de méthode, les sous-types peuvent modifier le mode de fonctionnement des méthodes disponibles via l'héritage.

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

  }
}

Exemple de sortie de polymorphisme:

Dans la méthode principale de la classe PolymorphismExample, j'ai créé trois objets: Car, Ford et Honda. Les trois objets sont référencés par le type de voiture.

Veuillez noter un point important ici qu'un type de super classe peut faire référence à un type d'objet de sous-classe mais le vice-verset n'est pas possible. La raison en est que tous les membres de la super classe sont disponibles pour la sous-classe en utilisant l'héritage et pendant le temps de compilation, le compilateur essaie d'évaluer si le type de référence que nous utilisons a la méthode à laquelle il essaie d'accéder.

Ainsi, pour les références car, f et h dans le PolymorphismExample, la méthode de déplacement existe à partir du type Car. Ainsi, le compilateur passe le processus de compilation sans aucun problème.

Mais en ce qui concerne l'exécution au moment de l'exécution, la machine virtuelle appelle les méthodes sur les objets qui sont des sous-types. Ainsi, la méthode move () est invoquée à partir de leurs implémentations respectives.

Ainsi, tous les objets sont de type Car, mais pendant l'exécution, l'exécution dépend de l'objet sur lequel l'invocation se produit. C'est ce qu'on appelle le polymorphisme.

Habituellement, cela fait référence à la capacité d'un objet de type A à se comporter comme un objet de type B. Dans la programmation orientée objet, cela est généralement obtenu par héritage. Quelques liens wikipedia pour en savoir plus:

• Polymorphisme dans la programmation orientée objet
• Polymorphisme de type

EDIT: liens rompus fixes.

Le polymorphisme est le suivant:

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
}

vous pouvez passer juste une coupe au lieu d'une instance spécifique. Cela aide en général car vous n'avez pas à fournir une instance de mesure () spécifique pour chaque type de tasse

Je sais que c'est une question plus ancienne avec beaucoup de bonnes réponses, mais j'aimerais inclure une réponse d'une phrase:

Traiter un type dérivé comme s'il s'agissait de son type de base.

Il existe de nombreux exemples ci-dessus qui montrent cela en action, mais je pense que c'est une bonne réponse concise.

(Je parcourais un autre article sur quelque chose de complètement différent .. et le polymorphisme est apparu ... Maintenant, je pensais que je savais ce qu'était le polymorphisme .... mais apparemment pas de cette belle manière expliqué .. Je voulais l'écrire quelque part .. mieux encore le partagera ...)

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

lire la suite de cette partie:

..... polymorphisme. C'est une façon geek de dire que différents noms peuvent avoir le même verbe appliqué à eux.

De manière générale, c'est la capacité d'interfacer un certain nombre de types d'objets différents en utilisant la même API ou une API superficiellement similaire. Il existe différentes formes:

• Surcharge de fonction: définir plusieurs fonctions avec le même nom et différents types de paramètres, tels que sqrt (float), sqrt (double) et sqrt (complex). Dans la plupart des langues qui le permettent, le compilateur sélectionne automatiquement le bon pour le type d'argument qui lui est transmis, il s'agit donc d'un polymorphisme à la compilation.

• Méthodes virtuelles en POO: une méthode d'une classe peut avoir différentes implémentations adaptées aux spécificités de ses sous-classes; chacun de ceux-ci remplacerait l'implémentation donnée dans la classe de base. Étant donné un objet qui peut appartenir à la classe de base ou à l'une de ses sous-classes, l'implémentation correcte est sélectionnée à la volée, il s'agit donc d'un polymorphisme d'exécution.

• Modèles: une fonctionnalité de certains langages OO par laquelle une fonction, une classe, etc. peut être paramétrée par un type. Par exemple, vous pouvez définir une classe de modèle générique "liste", puis l'instancier comme "liste d'entiers", "liste de chaînes", peut-être même "liste de listes de chaînes" ou similaires. Généralement, vous écrivez le code une fois pour une structure de données de type d'élément arbitraire et le compilateur en génère des versions pour les différents types d'élément.

Le terme polymorphisme vient de:

poly = plusieurs

morphisme = la capacité de changer

En programmation, le polymorphisme est une "technique" qui vous permet de "regarder" un objet comme étant plus d'un type de chose. Par exemple:

Un objet étudiant est également un objet personne. Si vous "regardez" (c.-à-d. Le casting) vers l'étudiant, vous pouvez probablement demander la carte d'étudiant. Vous ne pouvez pas toujours faire ça avec une personne, non? (une personne n'est pas nécessairement un étudiant, donc pourrait ne pas avoir de carte d'étudiant). Cependant, une personne a probablement un nom. Un étudiant aussi.

En bout de ligne, «regarder» le même objet sous différents «angles» peut vous donner différentes «perspectives» (c.-à-d. Différentes propriétés ou méthodes)

Cette technique vous permet donc de créer des éléments qui peuvent être «examinés» sous différents angles.

Pourquoi utilisons-nous le polymorphisme? Pour commencer ... l'abstraction. À ce stade, il devrait y avoir suffisamment d'informations :)

Prenons une analogie. Pour un scénario musical donné, chaque musicien qui le joue donne sa touche personnelle à l'interprétation.

Le musicien peut être abstrait avec des interfaces, le genre auquel appartient le musicien peut être une classe abstrac qui définit certaines règles globales d'interprétation et chaque musicien qui joue peut être modélisé avec une classe concrète.

Si vous êtes un auditeur de l'œuvre musicale, vous avez une référence au script, par exemple, 'Fuga et Tocata' de Bach et chaque musicien qui l'exécute le fait polymorphiquement à sa manière.

Ceci est juste un exemple d'une conception possible (en 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());
}

J'ai fourni un aperçu de haut niveau du polymorphisme pour une autre question:

Polymorphisme en c ++

J'espère que cela aide. Un extrait...

... cela permet de partir d'un simple test et d'une définition du [polymorphisme]. Considérez le code:

Type1 x;
Type2 y;

f(x);
f(y);

Ici, f()est d'effectuer une opération et reçoit les valeurs xet yles entrées. Pour être polymorphe, il f()doit être capable de fonctionner avec des valeurs d'au moins deux types distincts (par exemple, intet double), en trouvant et en exécutant du code approprié au type.

(suite à Polymorphism en c ++ )

Le polymorphisme est une capacité d'objet qui peut être prise sous de nombreuses formes. Par exemple, dans la classe humaine, un homme peut agir sous plusieurs formes lorsque nous parlons de relations. EX: Un homme est le père de son fils et il est le mari de sa femme et il enseigne à ses élèves.

Le polymorphisme est la capacité d'un objet à prendre de nombreuses formes. L'utilisation la plus courante du polymorphisme dans la POO se produit lorsqu'une référence de classe parent est utilisée pour faire référence à un objet de classe enfant. Dans cet exemple écrit en Java, nous avons trois types de véhicules. Nous créons trois objets différents et essayons d'exécuter leur méthode de roues:

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

}

Le résultat est:

Pour plus d'informations, veuillez visiter https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java . J'espère que ça aide.

Le polymorphisme est la capacité du programmeur à écrire des méthodes du même nom qui font des choses différentes pour différents types d'objets, selon les besoins de ces objets. Par exemple, si vous développiez une classe appelée Fractionet une classe appelée ComplexNumber, les deux pourraient inclure une méthode appelée display(), mais chacune implémenterait cette méthode différemment. En PHP, par exemple, vous pouvez l'implémenter comme ceci:

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

Les sorties:

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

Certaines des autres réponses semblent impliquer que le polymorphisme n'est utilisé qu'en conjonction avec l'héritage; par exemple, peut Fraction- être et les ComplexNumberdeux implémentent une classe abstraite appelée Numberqui a une méthode display(), que Fraction et ComplexNumber sont alors tous deux obligés d'implémenter. Mais vous n'avez pas besoin d' héritage pour profiter du polymorphisme.

Au moins dans les langages à typage dynamique comme PHP (je ne connais pas C ++ ou Java), le polymorphisme permet au développeur d'appeler une méthode sans nécessairement connaître le type d'objet à l'avance, et en ayant confiance que la mise en œuvre correcte de la méthode être appelé. Par exemple, supposons que l'utilisateur choisisse le type de Numbercréation:

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

Dans ce cas, la display()méthode appropriée sera appelée, même si le développeur ne peut pas savoir à l'avance si l'utilisateur choisira une fraction ou un nombre complexe.

Dans la programmation orientée objet, le polymorphisme fait référence à la capacité d'un langage de programmation à traiter les objets différemment selon leur type ou classe de données . Plus précisément, c'est la possibilité de redéfinir les méthodes des classes dérivées.

Le polymorphisme signifie littéralement plusieurs formes. (ou plusieurs formes): objet de différentes classes et méthode du même nom, mais les workflows sont différents. Un exemple simple serait:

Considérons une personne X.

Il n'est qu'une seule personne mais il en agit autant. Vous pouvez demander comment:

Il est le fils de sa mère. Un ami pour ses amis. Un frère pour sa sœur.

Le polymorphisme dans la POO signifie qu'une classe peut avoir différents types, l'héritage est une façon d'implémenter le polymorphisme.

par exemple, Shape est une interface, il a des sous-types Square , Circle , Diamond . maintenant que vous avez un objet Square, vous pouvez convertir automatiquement Square en forme, car Square est une forme. Mais lorsque vous essayez de downcasting Shape to Square, vous devez faire un transtypage de type explicite, car vous ne pouvez pas dire que Shape est Square, il peut également s'agir de Circle. vous devez donc le convertir manuellement avec du code comme Square s = (Square)shape, si la forme est Circle, vous obtiendrez java.lang.ClassCastException, car Circle n'est pas Square.

Polymorphisme:

Exécution différente selon l'instance de la classe, pas le type de variable de référence.

Une variable de référence de type d'interface peut faire référence à n'importe quelle instance de classe qui implémente cette interface.

Le polymorphisme est la capacité d'utiliser un objet dans une classe donnée, où tous les composants qui composent l'objet sont hérités par des sous-classes de la classe donnée. Cela signifie qu'une fois cet objet déclaré par une classe, toutes les sous-classes en dessous (et leurs sous-classes, et ainsi de suite jusqu'à ce que vous atteigniez la sous-classe la plus éloignée / la plus basse) héritent de l'objet et de ses composants (maquillage).

N'oubliez pas que chaque classe doit être enregistrée dans des fichiers séparés.

Le code suivant illustre le polymorphisme:

La SuperClasse:

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

Le père, une sous-classe:

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

L'enfant, une autre sous-classe:

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

La méthode d'exécution fait référence à la classe Parent pour démarrer:

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

Notez que chaque classe doit être déclarée dans des fichiers * .java distincts. Le code devrait compiler. Notez également que vous pouvez continuellement utiliser maidenName et familyTree plus bas. C'est le concept du polymorphisme. Le concept d'héritage est également exploré ici, où une classe peut être utilisée ou est définie par une sous-classe.

J'espère que cela aide et rend clair. Je publierai les résultats lorsque je trouverai un ordinateur que je pourrai utiliser pour vérifier le code. Merci pour la patience!

Le polymorphisme permet à la même routine (fonction, méthode) d'agir sur différents types.

Étant donné que de nombreuses réponses existantes confondent le sous-typage avec le polymorphisme, voici trois façons (y compris le sous-typage) d'implémenter le polymorphisme.

• Le polymorphisme paramétrique (générique) permet à une routine d'accepter un ou plusieurs paramètres de type, en plus des paramètres normaux, et s'exécute sur ces types.
• Le polymorphisme de sous-type permet à une routine d'agir sur n'importe quel sous-type de ses paramètres.
• Le polymorphisme ad hoc utilise généralement une surcharge de routine pour accorder un comportement polymorphe, mais peut également faire référence à d'autres implémentations de polymorphisme.

Voir également:

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

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

Dans les langages orientés objet, le polymorphisme permet de traiter et de gérer différents types de données via la même interface. Par exemple, considérons l'héritage en C ++: la classe B est dérivée de la classe A. Un pointeur de type A * (pointeur vers la classe A) peut être utilisé pour gérer à la fois un objet de classe A ET un objet de classe B.

Le polymorphisme en termes de codage, c'est quand votre objet peut exister en plusieurs types par héritage, etc. Si vous créez une classe nommée "Shape" qui définit le nombre de côtés de votre objet, vous pouvez alors créer une nouvelle classe qui en hérite comme "Square" ". Lorsque vous créez par la suite une instance de "Square", vous pouvez ensuite la lancer en avant et en arrière de "Shape" à "Square" selon les besoins.

Le polymorphisme vous donne la possibilité de créer un module appelant un autre, tout en ayant le point de dépendance temporelle de compilation par rapport au flux de contrôle plutôt qu'avec le flux de contrôle.

En utilisant le polymorphisme, un module de haut niveau ne dépend pas d'un module de bas niveau. Les deux dépendent des abstractions. Cela nous aide à appliquer le principe d'inversion de dépendance ( https://en.wikipedia.org/wiki/Dependency_inversion_principle ).

C'est là que j'ai trouvé la définition ci-dessus. Environ 50 minutes après le début de la vidéo, l'instructeur explique ce qui précède. https://www.youtube.com/watch?v=TMuno5RZNeE

Qu'est-ce que le polymorphisme?

Le polymorphisme est la capacité de:

• Invoquer une opération sur une instance d'un type spécialisé en ne connaissant que son type généralisé en appelant la méthode du type spécialisé et non celle du type généralisé: c'est du polymorphisme dynamique .

• Définissez plusieurs méthodes ayant le nom de sauvegarde mais ayant des paramètres différents: c'est le polymorphisme statique .

Le premier si la définition historique et le plus important.

À quoi sert le polymorphisme?

Il permet de créer une cohérence fortement typée de la hiérarchie des classes et de faire des choses magiques comme gérer des listes d'objets de différents types sans connaître leurs types mais un seul de leur type parent, ainsi que des liaisons de données.

Typage fort et faible

Échantillon

Voici quelques formes comme Point, Line, Rectangle et Circle dont l'opération Draw () ne prend rien ou un paramètre pour définir un délai d'expiration pour l'effacer.

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

Ici, la classe Shape et les méthodes Shape.Draw () doivent être marquées comme abstraites.

Ils ne sont pas là pour faire comprendre.

Explication

Sans polymorphisme, en utilisant abstract-virtual-override, lors de l'analyse des formes, seule la méthode Spahe.Draw () est appelée car le CLR ne sait pas quelle méthode appeler. Il appelle donc la méthode du type sur lequel nous agissons, et ici le type est Shape en raison de la déclaration de liste. Le code ne fait donc rien du tout.

Avec le polymorphisme, le CLR est capable d' inférer le type réel de l'objet sur lequel nous agissons en utilisant ce qu'on appelle une table virtuelle. Il appelle donc la bonne méthode, et ici appeler Shape.Draw () si Shape est Point appelle Point.Draw (). Le code dessine donc les formes.

Plus de lectures

C # - Polymorphisme (niveau 1)

Polymorphisme en Java (niveau 2)

Polymorphisme (Guide de programmation C #)

Table de méthode virtuelle