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

https://stackoverflow.com/questions/1031273

06-07-2019
|

Question

La solution

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

Poly = many: 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 = dieu grec du rêve 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 nombreuses langues, les entiers et les flottants sont implicitement polymorphes, car vous pouvez ajouter, soustraire, multiplier, etc., indépendamment du fait que les types sont différents. Ils sont rarement considérés comme des objets au terme habituel.

Mais, de la même manière, une classe telle que BigDecimal ou Rational ou Imaginary peut également fournir ces opérations, même si elles opèrent différents types de données.

L'exemple classique est la classe Shape 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 qu'elle se trouve bien entendu dans un espace à deux dimensions). Un cercle a besoin d'un centre et d'un rayon. Un carré ou un rectangle nécessite deux coordonnées pour les coins supérieur gauche et inférieur droit et (éventuellement) une rotation. Un polygone irrégulier nécessite 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 fonction Draw () 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 lesquelles 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 des concepts étroitement liés qu'il est essentiel de connaître. Il y a eu beaucoup de "balles d'argent". Au cours de ma longue carrière, qui a tout simplement fait long feu, mais le paradigme OO s’est avéré être bon. Apprenez-le, comprenez-le, aimez-le - vous ne le regretterez pas: -)

^(a) À l’origine, j’écrivais cela comme une blague, mais c’est avéré être correct et, par conséquent, pas si drôle. Le styrène momomère est fabriqué à partir de carbone et d'hydrogène, C ₈ H ₈ , et le polystyrène est fabriqué à partir de groupes de cela, (C ₈ H ₈) _n .

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

Parfois, vous devriez simplement arrêter de fumer pendant que vous êtes derrière: -)

Autres conseils

Le polymorphisme consiste à traiter un objet comme une version générique de quelque chose, mais lorsque vous y accédez, le code détermine le type exact dont 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 les éléments suivants 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 Vehicle, qui ne sait pas combien de roues a chacune de ses sous-classes, mais sait que chaque sous-classe est responsable de savoir combien de roues elle a. .

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 de manière identique. Toutefois, lorsque nous accédons à la propriété de chaque véhicule, la classe Vehicle délègue l'exécution de ce code à la sous-classe correspondante.

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

J'espère que cela vous aide.

De Compréhension et application du polymorphisme en PHP , merci Steve Guidetti.

Polymorphisme est un long mot 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 réside dans le fait 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 du polymorphisme dans le monde réel est un bouton. Tout le monde sait utiliser un bouton: vous appliquez simplement une pression dessus. Qu'est-ce qu'un bouton & # 8220; fait, & # 8221; Cependant, cela dépend de ce à quoi il est connecté et du contexte dans lequel il est utilisé & # 8212; mais le résultat n'affecte pas la façon dont il est utilisé. Si votre supérieur hiérarchique vous demande d’appuyer sur un bouton, vous disposez déjà de toutes les informations nécessaires pour effectuer cette tâche.

Dans le monde de la programmation, le polymorphisme est utilisé pour rendre les applications plus modulaires et extensibles. Au lieu d'énoncés conditionnels compliqués décrivant différents plans d'action, vous créez des objets interchangeables que vous sélectionnez en fonction de vos besoins. C’est l’objectif fondamental du polymorphisme.

Si quelqu'un dit CUT à ces personnes

Le chirurgien
Le coiffeur
l'acteur

Que va-t-il se passer?

Le chirurgien commencerait à pratiquer une incision.
Le coiffeur commencerait à couper les cheveux de quelqu'un.
L'acteur cesserait brusquement d'agir en dehors de la scène actuelle, en attente de conseils de direction.

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

Si vous allez passer une interview et que l'intervieweur vous demande de raconter / de montrer un exemple concret de polymorphisme dans la même pièce où nous sommes assis, par exemple -

Réponse - Porte / Fenêtres

Vous vous demandez comment?

À travers 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:

conseillers militaires
conseillers juridiques
Physiciens nucléaires (en tant que conseillers)
Conseillers médicaux
etc etc.

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

Le président n’est pas un expert du zingage ou de la physique quantique. Il ne sait pas grand chose, 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 des classes / personnes concernées. Autrement, le président aurait littéralement tout savoir dans le monde - la totalité de Wikipedia. Imaginez avoir toute la wikipedia dans une classe de votre code: ce serait un cauchemar à maintenir.

Pourquoi est-ce une mauvaise idée qu'un président connaisse toutes ces choses spécifiques?

Si le président disait spécifiquement aux gens quoi faire, cela voudrait dire que le président doit savoir exactement ce qu'il faut faire. Si le président a besoin de connaître certaines choses lui-même, cela signifie que lorsque vous devez effectuer un changement, vous devez le faire à deux endroits, pas à un seul.

Par exemple, si l’EPA modifie les lois sur la pollution, vous devrez modifier la classe EPA et la classe des présidents. Changer de code à deux endroits plutôt qu’à un seul peut être dangereux, car il est beaucoup plus difficile à maintenir.

Existe-t-il une meilleure approche?

Il existe une meilleure approche: le président n'a pas besoin de connaître les spécificités de quoi que ce soit - il peut exiger le meilleur conseil de la part de personnes spécifiquement chargées de faire ce genre de choses.

Il peut utiliser une approche polymorphe pour diriger le pays.

Exemple d'utilisation d'une approche polymorphe:

Tout ce que le président demande, c’est de demander aux gens de le conseiller - et c’est ce qu’il fait réellement - et c’est ce que devrait faire un bon président. ses conseillers répondent tous différemment, mais ils savent tous ce que le président veut dire par: Conseiller (). Des centaines de personnes affluent dans son bureau. Peu importe qui ils sont. Tout ce que le président sait, c’est que, quand 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 à la lettre, sans rien connaître aux affaires militaires, aux soins de santé ou à la diplomatie internationale: les détails sont laissés aux experts. La seule chose que le président doit savoir est la suivante: "Conseiller ()".

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 sait augmenter le nombre de soldats et les conditions préexistantes. Cela signifie que si les politiques du Moyen-Orient changent, le président devra alors modifier ses commandes, ainsi que la classe Petraeus. Nous devrions seulement devoir changer de classe Petraeus, car le président ne devrait pas avoir à s’enliser dans ce genre de détail. Il n'a pas besoin de connaître les détails. Tout ce qu'il a besoin de savoir, c'est que s'il passe une commande, tout sera pris en charge. Tous les détails devraient être laissés aux experts.

Cela permet au président de faire ce qu’il fait de mieux: définir une 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

C’est en fait un polymorphisme, en un mot. Comment fait-on exactement? En "mettant en place une interface commune" ou en utilisant une classe de base (héritage) - voir les réponses ci-dessus qui détaillent cela plus clairement. (Afin de mieux comprendre ce concept, vous devez savoir ce qu'est une interface et ce qu'est l'héritage. Sans cela, vous pourriez avoir du mal.)

En d’autres termes, Petraeus, Condi et HealthOfficials seraient toutes des classes qui "implémenteraient une interface". - appelons-le l'interface IAdvisor qui ne contient qu'une méthode: Advise () . Mais maintenant nous entrons dans les détails.

Ce serait l'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); } }

Résumé

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 à tous ceux qui franchissent la porte de le conseiller - et nous savons qu’ils sauront absolument quoi faire quand on leur demandera de le 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 réessayerai.

Le polymorphisme est la capacité de traiter une classe d'objet 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 Chien héritant d’Animal. Le polymorphisme est la capacité de traiter n'importe quel objet Chien en tant qu'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 est appelée 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 ailleurs qu’elle se trouve. 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: # / p>

Tout comme les champs d'une structure C sont dans un espace de noms protégé, sont des variables d'instance d'un objet.

Les noms de méthodes sont également protégés. Contrairement aux noms des fonctions C, Les noms de méthodes ne sont pas des symboles globaux. Le nom d'une méthode en un La classe ne peut pas entrer en conflit avec les noms de méthodes des autres classes; deux des classes très différentes peuvent implémenter des méthodes portant le même nom.

Les noms de méthode font partie de l’interface d’un objet. Lorsqu'un message est envoyé pour demander à un objet de faire quelque chose, il 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 appeler deux méthodes distinctes.

Le polymorphisme a pour principal avantage de simplifier l'interface de programmation. Cela 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 dans 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é dans Java à l'aide de la méthode de surcharge et de la méthode de substitution .

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

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

Créons maintenant un type de base Car

Car.java

public class Car { int price; String name; String color; public void move(){ System.out.println("Basic Car move"); } }

Mettons en œuvre l'exemple de la voiture Ford.

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 l'a toujours mise en œuvre à sa manière. Ceci s'appelle une méthode surchargée.

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 implémente la méthode de déplacement à sa manière.

Le remplacement de méthode est une fonctionnalité importante pour activer le polymorphisme. En utilisant le remplacement de méthode, les sous-types peuvent modifier le 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 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: un type de classe supérieure peut faire référence à un type d’objet de classe secondaire, 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 à l'aide de l'héritage et que pendant la compilation, le compilateur essaie d'évaluer si le type de référence que nous utilisons a la méthode à laquelle il tente d'accéder.

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

Mais en ce qui concerne l'exécution, la machine virtuelle appelle les méthodes sur les objets qui sont des sous-types. La méthode move () est donc 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 a lieu. C'est ce qu'on appelle le polymorphisme.

Il s'agit généralement de la possibilité pour un objet de type A de se comporter comme un objet de type B. En programmation orientée objet, cela se fait généralement par héritage. Quelques liens wikipedia pour en savoir plus:

Polymorphisme dans la programmation orientée objet

Polymorphisme de type

EDIT: correction des liens rompus.

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 ne pouvez passer qu’une coupe au lieu d’un cas spécifique. Cela facilite la tâche en général, car il n’est pas nécessaire de fournir une instance de measure () spécifique pour chaque type de gobelet

Je sais que c'est une question plus ancienne avec beaucoup de bonnes réponses, mais j'aimerais ajouter une réponse en 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 j'estime qu'il s'agit d'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 que le polymorphisme était .... mais apparemment pas de cette belle manière expliquée .. Voulait l'écrire quelque part .. mieux encore le partagerons))

http: //www.eioba. com / a / 1htn / comment-j'ai-expliqué-reste-à-ma-femme

lisez cette partie:

..... polymorphisme. C'est une façon géniale de dire que différents noms peuvent se voir appliquer le même verbe.

Le terme polymorphisme vient de:

poly = plusieurs

morphisme = la possibilité 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. coulé) à l’étudiant, vous pouvez probablement demander l’identifiant de l’étudiant. Vous ne pouvez pas toujours faire ça avec une personne, non? (une personne n’est pas nécessairement un étudiant, donc n’a peut-être pas de carte d’étudiant). Cependant, une personne a probablement un nom. Un étudiant aussi.

Résultat final, " recherche " au même objet sous différents "angles". peut vous donner des "perspectives" différentes (c.-à-d. propriétés ou méthodes différentes)

Cette technique vous permet donc de créer des éléments pouvant être "analysés". sous des angles différents.

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

De manière générale, il s’agit de la possibilité d’interfacer un certain nombre de types d’objets différents à l’aide d’une API identique ou superficielle. Il existe différentes formes:

Surcharge de fonctions: définition de plusieurs fonctions portant le même nom et différents types de paramètres, telles que sqrt (float), sqrt (double) et sqrt (complexe). Dans la plupart des langages qui le permettent, le compilateur sélectionne automatiquement celui qui convient pour le type d'argument transmis. Il s'agit donc d'un polymorphisme au moment de la compilation.

Méthodes virtuelles sous OOP: une méthode d'une classe peut avoir diverses implémentations adaptées aux spécificités de ses sous-classes; on dit que chacune d’elles remplace l’implémentation donnée dans la classe de base. Étant donné qu'un objet peut appartenir à la classe de base ou à l'une de ses sous-classes, la bonne implémentation est sélectionnée à la volée. Il s'agit donc d'un polymorphisme au moment de l'exécution.

Modèles: fonctionnalité de certains langages orientés objet dans laquelle une fonction, une classe, etc. peut être paramétrée par un type. Par exemple, vous pouvez définir une "liste" générique. classe de modèle, puis l’instancier en tant que "liste d’entiers", "liste de chaînes", peut-être même "liste de listes de chaînes". ou semblable. 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.

Utilisons une analogie. Pour un scénario musical donné, chaque musicien qui le joue donne sa propre touche d'interprétation.

Le musicien peut être résumé avec des interfaces, le genre auquel le musicien appartient peut être une classe d'abstraction définissant des règles d'interprétation globales et chaque musicien jouant peut être modelé avec une classe concrète.

Si vous écoutez l’œuvre musicale, vous avez une référence au script, par exemple. "Fuga and Tocata" de Bach et chaque musicien qui le joue le font de manière polymorphe à sa manière.

Ceci n'est qu'un exemple de 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 une vue d'ensemble de haut niveau sur le polymorphisme pour une autre question:

Polymorphisme en c ++

J'espère que ça aide. Un extrait ...


... il est utile de commencer par un simple test et la définition du [polymorphisme]. Considérons le code:

Type1 x; Type2 y; f(x); f(y);


Ici, f () doit exécuter une opération et reçoit les valeurs x et y en tant qu'entrées. Pour être polymorphe, f () doit pouvoir fonctionner avec des valeurs d'au moins deux types distincts (par exemple, int et double ), recherche et exécution du code approprié au type.

(suite sur Polymorphisme en c ++ )

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

Le polymorphisme est la capacité d’un objet à revêtir de nombreuses formes. L'utilisation la plus courante du polymorphisme dans la programmation orientée objet 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 des 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, consultez la page 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, en fonction des besoins de ces objets. Par exemple, si vous développiez une classe appelée Fraction et une classe appelée ComplexNumber , ces deux méthodes pourraient inclure une méthode appelée display () , mais chacun d'entre eux mettrait en œuvre 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";

Sorties:

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

Certaines autres réponses semblent impliquer que le polymorphisme n’est utilisé que conjointement avec l’héritage; Par exemple, Fraction et ComplexNumber implémentent tous deux une classe abstraite appelée Number ayant une méthode display () , que Fraction et ComplexNumber sont alors tous deux obligés de mettre en œuvre. Mais vous n'avez pas besoin d'héritage pour tirer parti du polymorphisme.

Au moins dans les langages à typage dynamique tels que PHP (je ne connais pas C ++ ni 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 se fiant à la bonne implémentation de la méthode sera appelée. Par exemple, supposons que l’utilisateur choisisse le type de numéro créé:

$userNumberChoice = 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, en fonction des besoins de ces objets. Par exemple, si vous développiez une classe appelée Fraction et une classe appelée ComplexNumber , ces deux méthodes pourraient inclure une méthode appelée display () , mais chacun d'entre eux mettrait en œuvre 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"; Sorties: This is a fraction: 1/2 This is a complex number: 1 + 2i Certaines autres réponses semblent impliquer que le polymorphisme n’est utilisé que conjointement avec l’héritage; Par exemple, Fraction et ComplexNumber implémentent tous deux une classe abstraite appelée Number ayant une méthode display () , que Fraction et ComplexNumber sont alors tous deux obligés de mettre en œuvre. Mais vous n'avez pas besoin d'héritage pour tirer parti du polymorphisme. Au moins dans les langages à typage dynamique tels que PHP (je ne connais pas C ++ ni 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 se fiant à la bonne implémentation de la méthode sera appelée. Par exemple, supposons que l’utilisateur choisisse le type de numéro créé: <*> Dans ce cas, la méthode display () 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. 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 méthode display () 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 de données ou leur classe . Plus spécifiquement, il s’agit de la possibilité de redéfinir les méthodes pour les classes dérivées.

Polymorphisme signifie littéralement, plusieurs formes. (ou plusieurs formes): Objet de classes différentes 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 un fils de sa mère. Un ami à ses amis. Un frère à sa soeur.

Polymorphisme dans la POO signifie qu'une classe peut avoir différents types, l'héritage est un moyen d'implémenter le polymorphisme.

Par exemple, Forme est une interface comportant des sous-types Carré , Cercle , Diamant . Maintenant que vous avez un objet Square, vous pouvez convertir la forme de Square en forme automatiquement, car Square est une forme. Cependant, lorsque vous essayez de convertir Shape en Square, vous devez effectuer 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 lancer manuellement avec un code comme Square s = (carré) forme , et si la forme est Circle, vous obtiendrez java.lang.ClassCastException , car Circle est pas carré.

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 à l'une des instances de classe qui implémentent cette interface.

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

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

Le code suivant illustre le polymorphisme:

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

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, référence la classe parente à 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 séparés. Le code devrait compiler. Notez également que vous pouvez toujours utiliser maidenName et familyTree plus loin. C'est le concept de polymorphisme. La notion d'héritage est également explorée ici, où une classe est utilisable ou est définie plus en détail par une sous-classe.

J'espère que cela aide et clarifie les choses. 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 associent sous-typage et polymorphisme, il existe trois façons (y compris le sous-typage) de mettre en œuvre le polymorphisme.

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 elle-même sur ces types.

Polymorphisme de sous-type permet à une routine d’agir sur n’importe quel sous-type de ses paramètres.

Polymorphisme ad hoc utilise généralement la surcharge de routine pour accorder un comportement polymorphe, mais peut également faire référence à d'autres implémentations de polymorphisme.

Voir aussi:

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

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

Dans les langues orientées objet, le polymorphisme permet le traitement et la gestion de 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.

En termes de codage, le polymorphisme est le moment où votre objet peut exister sous forme de 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 ensuite créer une nouvelle classe qui en hérite, telle que "Square". Lorsque vous créez ensuite une instance de " Square " vous pouvez ensuite le renvoyer à partir de " Shape " à " Square " au besoin.

Le polymorphisme vous permet de créer un module en appelant un autre, tout en disposant du point de dépendance du temps de compilation par rapport au flux de contrôle au lieu du flux de contrôle.

En utilisant le polymorphisme, un module de haut niveau ne dépend pas du 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 ici 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

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow