Qu'est-ce que le polymorphisme, à quoi sert-il et comment est-il utilisé?
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 (une), polyglotte = beaucoup de 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 et ainsi de suite, 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 BigDecimalou Rationalou Imaginarypeut également fournir ces opérations, même si elles fonctionnent sur des types de données différents.
L'exemple classique est la classe Shapeet 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 différentes données sous-jacentes. 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.
Ceci est en 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 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 ont tout simplement fait long feu, mais le paradigme OO s'est révélé bon. Apprenez-le, comprenez-le, aimez-le - vous ne le regretterez pas :-)
(une) À l’origine, j’écrivais cela comme une blague, mais c’est vrai et donc, pas si drôle. Le styrène momomère est fabriqué à partir de carbone et d'hydrogène, C8H8, et le polystyrène est fabriqué à partir de groupes de celui-ci, (C8H8)n.
J'aurais peut-être dû dire qu'un polype figurait à 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, tu devrais arrêter quand tu es derrière :-)
Le polymorphisme est le moment où vous pouvez traiter un objet comme une version générique de quelque chose, mais lorsque vous y accédez, le code détermine son type exact 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;
}
}
Maintenant, créez 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 Vehicle, qui ne sait pas combien de roues a chacune de ses sous-classes, mais sait que chaque sous-classe est responsable de connaître le nombre de roues dont elle dispose.
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 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 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 ils sont tous utilisés 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. Cependant, ce qu'un bouton “fait” dépend de son lien 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 demande 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 compliquées décrivant différentes actions, 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
Qu'est-ce qui va arriver?
- Le chirurgien commencerait à faire une incision.
- Le coiffeur commencerait à couper les cheveux de quelqu'un.
- L’acteur cesserait brusquement d’agir en dehors de la scène actuelle, dans l’attente des conseils de la direction.
La représentation ci-dessus montre donc Qu'est-ce qu'un polymorphisme (même nom, comportement différent) en POO?.
Si vous allez passer une interview et que l'enquêteur vous demande de raconter/de montrer un exemple vivant de polymorphisme dans la même pièce où nous sommes assis, par exemple…
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 de 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.
Tout le monde ne devrait être responsable que d'une chose: Exemple:
Le président n'est pas un expert en zingage ou en 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 la totalité de wikipedia dans une classe de votre code: ce serait un cauchemar à entretenir.
Pourquoi est-ce une mauvaise idée pour un président de savoir 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, il faut alors modifier la classe EPA et aussi la classe de président. Changer le code à deux endroits plutôt qu’à un seul peut être dangereux, car il est beaucoup plus difficile à maintenir.
Y a-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 ces tâches.
Il peut utiliser une approche polymorphe pour diriger le pays.
Exemple - d’utiliser 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 dans la vie réelle - et c'est ce qu'un bon président devrait faire. 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 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 connaître aux affaires militaires, aux soins de santé ou à la diplomatie internationale: les détails sont laissés à des 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 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
C'est en fait un polymorphisme, en un mot. Comment fait-on exactement? En "mettant en oeuvre une interface commune" o 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 vous devez comprendre ce qu'est l'héritage. Sans cela, vous pourriez vous débattre.)
En d'autres termes, Petraeus, Condi et HealthOfficials seraient toutes des classes qui "implémentent une interface" - appelons-la l'interface IAdvisor qui contient seulement 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 aide. 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 Dog qui hérite de Animal. Le polymorphisme est la capacité de traiter n'importe quel objet Dog 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 ne sont 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 cet objet:
Tout comme les champs d’une structure C se trouvent dans un espace de noms protégé, il en va de même pour les 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 d’une classe ne peut pas entrer en conflit avec les noms de méthodes d’autres classes; deux classes très différentes peuvent implémenter des méthodes portant le même nom.
Les noms de méthodes 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 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é dans Java à l'aide de la méthode surcharge et de la méthode substitution concepts.
Prenons l'exemple de Car pour discuter du polymorphisme. Prenez n'importe quelle marque comme Ford, Honda, Toyota, BMW, 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.
Maintenant, laissez-nous créer 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. Cela 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 caractéristique importante pour activer le polymorphisme. À l'aide du 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 super classe peut faire référence à un type d'objet de sous-classe mais le vice-vers 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. Ainsi, le compilateur passe le processus de compilation sans aucun 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. 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 a lieu. Ceci s'appelle le polymorphisme.
Habituellement, il s'agit 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:
EDIT: liens cassés 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 tasse au lieu d'un cas spécifique. Cela aide en général car vous n'avez pas à fournir une instance de measure () spécifique pour chaque type de tasse.
(Je parcourais un autre article sur quelque chose de tout à fait différent… et le polymorphisme est apparu… Maintenant, je pensais que je savais ce que le polymorphisme était… mais apparemment, pas de cette belle façon, expliqué… je voulais l'écrire quelque part…. mieux encore le partagerons ...)
http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife
lisez la suite de cette partie:
..... polymorphisme. C'est une façon géniale de dire que différents noms peuvent se voir appliquer le même verbe.
Je sais que c'est une question plus ancienne avec beaucoup de bonnes réponses, mais j'aimerais inclure une réponse en une phrase:
Traiter un type dérivé comme s'il s'agissait de son type de base.
Les exemples ci-dessus montrent de nombreux exemples, mais j'estime qu'il s'agit d'une bonne réponse concise.
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. Casté) sur l'étudiant, vous pouvez probablement demander le code d'étudiant. Vous ne pouvez pas toujours faire ça avec une personne, non? (une personne n’est pas nécessairement un étudiant, n’a peut-être pas 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'est-à-dire différentes propriétés ou méthodes)
Donc, cette technique vous permet de construire des choses qui peuvent être "regardées" sous différents angles.
Pourquoi utilisons-nous le polymorphisme? Pour commencer ... l'abstraction. À ce stade, il devrait être assez d'infos :)
De manière générale, il s'agit de la possibilité d'interfacer un certain nombre de types d'objets en utilisant la même API ou une API superficiellement similaire. 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 qui y est passé. Il s'agit donc d'un polymorphisme au moment de la compilation.
Méthodes virtuelles en POO: 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 quelques OO langues dans lesquelles une fonction, une classe, etc. peut être paramétrée par un type. Par exemple, vous pouvez définir une classe de modèle "liste" générique, puis l'instancier en tant que "liste d'entiers", "liste de chaînes", voire "liste de listes de chaînes" ou autres. 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.
J'ai fourni un aperçu de haut niveau du polymorphisme pour une autre question:
J'espère que ça aide. Un extrait...
... il est utile de commencer par un simple test et par 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 valeursxetyen tant qu'entrées. Pour être polymorphe,f()doit pouvoir utiliser des valeurs d'au moins deux types distincts (par exemple,intetdouble), en recherchant et en exécutant du code approprié au type.
(suite à 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 enseigne à ses étudiants.
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'abstracs qui définit certaines règles globales d'interprétation et chaque musicien qui joue 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 est juste 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());
}
Le polymorphisme est la capacité d'un objet à prendre de nombreuses formes. L'utilisation la plus courante du polymorphisme dans OOP 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, veuillez visiter le site 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 Fractionet une classe appelée ComplexNumbername__, elles pourraient toutes deux inclure une méthode appelée display(), mais chacune d'entre elles 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 est utilisé uniquement en conjonction avec l'héritage; Par exemple, peut-être Fractionet ComplexNumberimplémentent-ils une classe abstraite appelée Numberqui a une méthode display(), que Fraction et ComplexNumber sont 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 le 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 se fiant à la la mise en œuvre correcte de la méthode sera appelée. Par exemple, supposons que l'utilisateur choisisse le type de Numbercreated:
$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 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.
Polymorphisme dans OOP signifie qu'une classe peut avoir différents types, l'héritage est un moyen d'implémenter le polymorphisme.
par exemple, Shape est une interface, elle comporte carré, cercle, losange. 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 tel que Square s = (Square)shape; si la forme est Circle, vous obtiendrez Java.lang.ClassCastException, car Circle n’est pas un 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.
Dans la programmation orientée objet, le polymorphisme fait référence à un langage de programmation possibilité de traiter des objets différemment en fonction de leur type de données ou de 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 forme multiple): Objet de classes différentes et de la même méthode de nom, mais les workflows sont différents. Un exemple simple serait:
Considérons une personne X.
Il n’est qu’une personne mais il en agit autant. Vous pouvez demander comment:
Il est un fils à sa mère. Un ami à ses amis. Un frère à sa soeur.
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 méthodes (y compris le sous-typage) pour 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.
- 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 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)
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 des 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 inférieures (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).
Rappelez-vous que chaque classe doit être enregistrée dans des fichiers séparés.
Le code suivant illustre le polymorphisme:
The 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 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 toujours utiliser maidenName et familyTree plus loin. C'est le concept de polymorphisme. Le concept d'héritage est également exploré 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 vous donne la possibilité de créer un module en appelant un autre, tout en disposant du point de dépendance de la durée 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 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
Le polymorphisme en termes de codage se produit lorsque 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 créer une nouvelle classe qui en hérite, telle que "Square". ". Lorsque vous créez par la suite une instance de "Square", vous pouvez la rediffuser et la faire passer de "Shape" à "Square" selon vos besoins.
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 un objet de classe A ET un objet de classe B.