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

voici un exemple en C#. Créer 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éer 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 le véhicule de la classe de base, qui ne sait pas combien de roues chacune de ses sous-classes A, mais qui sait que chaque sous-classe est responsable de savoir combien de roues elle a.

nous ajoutons ensuite une bicyclette, une voiture et un camion à la liste.

ensuite, nous pouvons passer en boucle à travers chaque véhicule de la liste, et les traiter tous de manière identique, cependant, lorsque nous accédons à la propriété de chaque véhicule "roues", la classe de véhicule délègue l'exécution de ce code à la sous-classe.

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

j'espère que cela vous aide.

à Partir de la Compréhension et l'Application du Polymorphisme dans PHP , Merci Steve Guidetti.

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

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 fonctionne avec les différentes classes n'a pas besoin de savoir quelle classe il utilise puisqu'ils sont tous utilisés de la même manière. Un monde réel analogie pour le polymorphisme est un bouton. Tout le monde sait utiliser un bouton: il suffit d'appuyer dessus. Ce qu'un bouton "ne", cependant, dépend de ce qu'il est connecté et que le 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 avez déjà 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'énoncés conditionnels désordonnés décrivant différentes lignes d'action, vous créez des objets interchangeables que vous sélectionnez en fonction de vos besoins. C'est le but fondamental du polymorphisme.

si quelqu'un dit coupez à ces gens

1. Le Chirurgien
2. Le Coiffeur
3. L'Acteur

que se passera-t-il?

• le chirurgien commencerait à faire une incision.
• le coiffeur commencerait à couper les cheveux de quelqu'un.
• l'acteur arrêterait brusquement de jouer hors du courant scène, en attente de mise en scène d'orientation.

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

si vous allez à une entrevue et que l'intervieweur vous demande de donner/montrer un exemple réel de polymorphisme dans la même salle où nous sommes assis, dites -

Réponse Portes / Fenêtres

Se Demandant Comment?

par la Porte / Fenêtre - une personne peut venez, l'air peut venir, la lumière peut venir, la pluie peut venir, etc.

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

polymorphisme:

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

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

• tout comme les champs D'une structure en C sont dans un espace de nom protégé, ainsi sont une instance de l'objet de variables.

Les noms de méthodes

• sont également protégés. Contrairement au nom des fonctions C, les noms de méthode ne sont pas des symboles globaux. Le nom d'une méthode dans un classe ne peut pas entrer en conflit avec les noms de méthode dans d'autres classes; deux des classes très différentes peut mettre en œuvre des méthodes nommées de façon identique.

les noms de méthodes font partie de l'interface d'un objet. Quand un message est envoyé demandant qu'un objet fasse quelque chose, le message nomme la méthode que l'objet doit effectuer. Parce que différents objets peuvent avoir des méthodes avec 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 peuvent 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 dans une classe après l'autre. Au lieu d'inventer un nouveau nom pour chaque nouvelle fonction, vous pouvez l'ajouter à 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 mettent en œuvre.

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: Polymorphisme est mis en œuvre dans Java l'aide de la méthode surcharge et la méthode substitution concepts.

considérons exemple de voiture pour discuter du polymorphisme. Prendre toute marque comme Ford, Honda, Toyota, BMW, Benz etc. Tout est de type Voiture.

mais chacun a ses propres caractéristiques avancées et la technologie plus avancée impliquée dans leur comportement de déplacement.

maintenant, créons une voiture de type de base

de la Voiture.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 voiture Ford.

Ford étend la voiture de type pour hériter 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 Ford classe étend la classe de Voiture et met également en œuvre la méthode move (). Même si la méthode move est déjà disponible pour Ford par le biais de L'héritage, Ford a encore mis en œuvre la méthode à sa propre manière. Ceci est appelé la redéfinition 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 move dans son propre chemin.

est une caractéristique importante pour permettre le polymorphisme. En utilisant la méthode overriding, les sous-types peuvent changer la façon dont les méthodes fonctionnent qui sont disponibles à travers 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();

  }
}

Polymorphisme Exemple De Sortie:

dans la méthode principale de la classe PolymorphismExample, j'ai créé trois objets - voiture, Ford et Honda. Tous les trois objets sont référé par le type de voiture.

s'il vous plaît noter un point important ici Qu'un type de super classe peut se référer à un type de sous-classe d'objet, mais le vice-verset n'est pas possible. La raison en est que tous les membres de la classe super 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 voiture, f et h dans le PolymorphismExample, la méthode move existe de type de la Voiture. Ainsi, le compilateur passe le processus de compilation sans aucun problème.

mais quand il s'agit de l'exécution du temps d'exécution, la machine virtuelle invoque 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.

Donc, tous les objets sont de type Voiture, mais pendant le temps d'exécution, l'exécution dépend de l'Objet sur lequel l'invocation arriver. Cela s'appelle le polymorphisme.

polymorphisme est la capacité de traiter une classe d'objet comme si elle est la classe mère.

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

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

explication Simple par analogie

le Président des États-Unis emploie le polymorphisme. Comment? 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 pour une chose: exemple:

Le président n'est pas un expert en revêtement de zinc, ou de la 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 aux classes/personnes concernées. Sinon, vous auriez le président sachant littéralement tout dans le monde - toute la Wikipédia. Imaginez avoir toute la Wikipédia 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?

si le président devait spécifiquement dire aux gens ce qu'ils doivent faire, cela signifierait que le président doit savoir exactement ce qu'il faut faire. Si le président a besoin de savoir des choses spécifiques lui-même, cela signifie que lorsque vous avez besoin de faire un changement, alors vous aurez besoin pour le faire en deux endroits, pas seulement un.

par exemple, si L'EPA modifie les lois sur la pollution, alors quand cela arrive: vous devez faire un changement à la classe de L'EPA et aussi la classe du Président. Changer le code à deux endroits plutôt qu'à un seul peut être dangereux - parce que c'est beaucoup plus difficile à maintenir.

y a-t-il une meilleure approche?

il y a un meilleur 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 est de demander aux gens de le conseiller - et c'est ce qu'il fait réellement dans le réel la vie - et qu'est ce qu'un bon président doit faire. ses conseillers répondent tous différemment, mais ils savent tous ce que le Président veut dire par: Conseiller(). Il a des centaines de personnes dans son bureau. Il n'a pas vraiment d'importance qui ils sont. Tout ce que le président sait, c'est que lorsqu'il leur demande de "conseiller", ils savent comment répondre 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  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 ceci: "Advise()".

Ce que vous NE souhaitez 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! PAS de! PAS de! Dans le scénario ci-dessus, le président fait tout le travail: il est au courant de l'augmentation du nombre de troupes et des conditions préexistantes. Cela signifie que si le moyen-orient les politiques changent, alors le président devrait changer ses commandes, ainsi que la classe Petraeus aussi bien. Nous ne devrions avoir qu'à changer la classe Petraeus, parce que 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 doit savoir, c'est que s'il passe une commande, tout sera réglé. Tous les détails devraient être confiés aux experts.

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

Comment est - il réellement mis en œuvre-à travers une classe de base ou une interface commune

c'est en effet du polymorphisme, en un mot. Exactement comment est-il fait? Par "implémenter une interface commune " ou en utilisant une classe de base (héritage) - voir les réponses ci-dessus qui détaillent ceci plus clairement. (Afin de mieux comprendre ce concept, vous besoin de savoir ce qu'est une interface, et vous aurez besoin de comprendre ce que l'héritage est. Sans ça, vous pourriez vous battre.)

en d'autres termes, Petraeus, Conditional et HealthOfficials seraient tous des classes qui" implémentent une interface "- appelons-le l'interface IAdvisor qui ne contient qu'une méthode: Advise() . Mais nous entrons maintenant 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);
        }
    }

résumé

Tout ce que vous devez savoir 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 marche dans la porte pour le conseiller - et nous savons qu'ils sauront absolument quoi faire lorsqu'on leur demandera de le conseiller (parce qu'ils sont tous dans la réalité, conseillers (ou conseillers:))

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

se réfère habituellement à la capacité d'un objet de type a de se comporter comme un objet de type B. Dans la programmation orientée objet, ceci est généralement atteint par héritage. Quelques liens Wikipédia pour en savoir plus:

• polymorphisme dans la programmation orientée objet
• polymorphisme de Type

EDIT: corrected broken links.

polymorphisme:

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'une instance spécifique. Cela aide dans la généralité parce que vous ne devez pas fournir une mesure spécifique() instance par chaque type de coupe

je sais que c'est une vieille question avec beaucoup de bonnes réponses, mais j'aimerais inclure une phrase réponse:

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

il y a beaucoup d'exemples ci-dessus qui montrent ceci dans l'action, mais je pense que c'est une bonne réponse concise.

(je parcourais un autre article sur quelque chose d'entièrement différent.. et le polymorphisme surgi... Je croyais savoir ce Qu'était le polymorphisme.... mais apparemment pas de cette belle façon expliquée.. Voulais l'écrire quelque part.. mieux encore en fera part... )

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

lire la suite de cette partie:

..... polymorphisme. C'est un geek manière de dire que les différents noms peuvent avoir le même verbe est appliquée.

le terme polymorphisme vient de:

poly = plusieurs

morphism = la capacité de changer de

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

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

conclusion, "regarder" le même objet sous des "angles" différents peut vous donner des "perspectives" différentes (c.-à-d. des propriétés ou des méthodes différentes)

donc cette technique vous permet de construire des choses qui peuvent être" regardées " sous différents angles.

Pourquoi utilisons-nous le polymorphisme? Pour les débutants ... abstraction. À ce stade, il devrait être assez d'info :)

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

• overloading de fonction: définition de fonctions multiples avec le même nom et différents types de paramètres, tels que sqrt(float), sqrt(double) et sqrt(complexe). Dans la plupart des langues qui permettent cela, le compilateur sélectionnera automatiquement le bon pour le type d'argument il s'agit donc d'un polymorphisme de compilation.

• méthodes virtuelles en OOP: une méthode d'une classe peut avoir diverses implémentations adaptées aux spécificités de ses sous-classes; chacune d'elles est censée primer l'implémentation donnée dans la classe de base. Étant donné un objet qui peut être de la classe de base ou de l'une de ses sous-classes, l'implémentation correcte est sélectionnée à la volée, donc c'est du polymorphisme d'exécution.

• Modèles: une caractéristique de certains langages à objets en vertu de laquelle une fonction, classe, etc. peut être paramétré par un type. Par exemple, vous pouvez définir un générique de "liste" de classe de modèle, et ensuite instancier comme "liste de nombres entiers", "liste des chaînes", peut-être même "liste de listes de chaînes". 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éments.

utilisons une analogie. Pour un scénario musical donné chaque musicien qui le joue donne sa propre touche dans l'interprétation.

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

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

ce n'est qu'un exemple d'un dessin 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());
}

polymorphisme est la capacité du programmeur d'é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 , tous les deux pourraient inclure une méthode appelée display() , mais chacun d'eux 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";

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é seulement en conjonction avec l'hérédité; par exemple, peut-être Fraction et ComplexNumber tous les deux mettent en œuvre une classe abstraite appelée Number qui a une méthode display() , qui Fraction et ComplexNumber sont alors tous deux obligés de mettre en œuvre. Mais vous ne pas besoin héritage pour tirer profit du polymorphisme.

au moins dans les langages dynamiquement typés comme PHP (Je ne sais 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 confiant que la mise en œuvre correcte de la méthode sera appelée. Par exemple, disons que l'utilisateur choisit le type de Number créé:

$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 appropriée display() sera appelée, même si le développeur ne peut pas savoir à l'avance si l'utilisateur choisit une fraction ou un nombre complexe.

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

polymorphisme en c++

j'Espère que ça aide. Extrait...

... il est utile de partir d'un simple test de dépistage et de définition du [polymorphisme]. Considérons le code:

Type1 x;
Type2 y;

f(x);
f(y);

ici, f() est d'effectuer une certaine opération et est étant donné les valeurs x et y comme entrées. Pour être polymorphique, f() doit pouvoir fonctionner avec des valeurs d'au moins deux types distincts (par exemple int et double ), trouver et exécuter le code approprié au type.

(suite à polymorphisme en c++ )

polymorphisme signifie littéralement, formes multiples. (ou beaucoup de forme) : Objet de classes différentes et méthode du même nom, mais les flux de travail sont différents. Un exemple simple serait:

Considérer une personne X.

il n'est qu'une personne, mais il en est autant. Vous pouvez vous demander comment:

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

polymorphisme dans OOP signifie qu'une classe pourrait avoir différents types, l'héritage est une façon de mettre en œuvre le polymorphisme.

par exemple, Forme est une interface, il a Carré , Cercle , Diamant sous-types. maintenant vous avez un objet carré, vous pouvez upcasting carré pour former automatiquement, parce que carré est une forme. Mais quand vous essayez de downcasting forme à Carré, vous doit faire un moulage de type explicite, parce que vous ne pouvez pas dire que la forme est carrée, elle pourrait être en cercle aussi. donc vous avez besoin de le mouler manuellement avec du code comme Square s = (Square)shape , et si la forme est en cercle , vous obtiendrez java.lang.ClassCastException , parce que le cercle n'est pas Carré.

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

polymorphisme est une capacité de l'objet qui peut être pris sous de nombreuses formes. Par exemple dans la classe humaine un homme peut agir dans de nombreuses formes quand nous parlons de relations. EX: un homme est le père de son fils, il est le mari de sa femme et il est le maître de ses élèves.

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 renvoyer à n'importe quelle instance de classe qui implémente cette interface.

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 de parent est utilisée pour désigner un objet de classe d'enfant. Dans cet exemple qui est écrit en Java, nous avons trois types de véhicule. 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'information, veuillez visiter https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java . J'espère que cela aide.

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) de mettre en œuvre le polymorphisme.

• parameteric (generic) polymorphism 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 la surcharge de routine pour accorder le comportement polymorphe, mais peut se référer à d'autres implémentations de polymorphisme aussi.

voir aussi:

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

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

dans les langages orientés objet, le polymorphisme permet le traitement et la manipulation de différents types de données à travers 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 manipuler à la fois un objet de la classe A et un objet de la classe B.

polymorphisme en termes de codage est quand votre objet peut exister comme plusieurs types par l'héritage, etc. Si vous créez une classe appelée "Shape" qui définit le nombre de côtés de votre objet, vous pouvez alors créer une nouvelle classe qui hérite comme "Square". Quand vous faites par la suite une instance de "Carré", vous pouvez la lancer en arrière et en avant de "forme" à "carré" comme demandé.

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

rappelez-vous que chaque classe doit être sauvegardée dans des fichiers séparés.

le le code suivant illustre le polymorphisme:

La Super-Classe:

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, les références Parent classe de départ:

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

noter que chaque classe doit être déclarée séparément *.les fichiers java. Le code devrait être compilé. Remarquez également que vous pouvez continuellement utiliser maidenName et familyTree plus bas. C'est le concept de polymorphisme. Le concept d'héritage est également exploré ici, où une classe peut être utilisée ou est définie plus en détail par une sous-classe.

Espérons que cela aide et il est clair. Que je affichasse les résultats quand je trouve un ordinateur que je peux utiliser pour vérifier le code. Merci pour la patience!

polymorphisme vous donne la possibilité de créer un module appelant un autre, et pourtant avoir le point de dépendance temps de compilation contre le 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 du module de bas niveau. Les deux dépendent des abstractions. Cela nous aide à appliquer le principe de l'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