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


Answers

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

Voici un exemple en C #. Créez quatre classes dans une application de console:

public abstract class Vehicle
{
    public abstract int Wheels;
}

public class Bicycle : Vehicle
{
    public override int Wheels()
    {
        return 2;
    }
}

public class Car : Vehicle
{
    public override int Wheels()
    {
        return 4;
    }
}

public class Truck : Vehicle
{
    public override int Wheels()
    {
        return 18;
    }
}

Créez maintenant ce qui suit dans 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 connaît pas le nombre de roues de chacune de ses sous-classes, mais qui sait que chaque sous-classe est responsable de savoir combien de roues elle possède.

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

Ensuite, nous pouvons parcourir chaque véhicule de la liste et les traiter tous de la même façon. Cependant, lorsque nous accédons à la propriété de chaque véhicule, la classe Véhicule délègue l'exécution de ce code à la sous-classe concernée.

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

J'espère que cela vous aide.

Question

Je regardais une vidéo de Google Tech Talks , et ils faisaient souvent référence au polymorphisme.

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




Polymorphism is an ability of object which can be taken in many forms. For example in human class a man can act in many forms when we talk about relationships. EX: A man is a father to his son and he is husband to his wife and he is teacher to his students.




Si quelqu'un dit CUT à ces personnes

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

Que va-t-il arriver?

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

Donc, au-dessus de la représentation montre Qu'est-ce que le polymorphisme (même nom, comportement différent) dans OOP.

Si vous vous présentez pour une entrevue et que l'intervieweur vous demande de montrer / montrer un exemple vivant de polymorphisme dans la même pièce où nous sommes assis, dites ...

Réponse - Porte / Fenêtres

Vous vous demandez comment?

Grâce à 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 d'une manière simple j'ai utilisé l'exemple ci-dessus .. Si vous avez besoin de référence pour le code suivre les réponses ci-dessus.




Polymorphism is the ability of an object to take on many forms. The most common use of polymorphism in OOP occurs when a parent class reference is used to refer to a child class object. In this example that is written in Java, we have three type of vehicle. We create three different object and try to run their wheels method:

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

}

The result is:

For more information please visit https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java . J'espère que ça aide.




Polymorphism in OOP means a class could have different types, inheritance is one way of implementing polymorphism.

for example, Shape is an interface, it has Square , Circle , Diamond subtypes. now you have a Square object, you can upcasting Square to Shape automatically, because Square is a Shape. But when you try to downcasting Shape to Square, you must do explicit type casting, because you can't say Shape is Square, it could be Circle as well. so you need manually cast it with code like Square s = (Square)shape , what if the shape is Circle, you will get java.lang.ClassCastException , because Circle is not Square.




Le terme polymorphisme vient de:

poly = beaucoup

morphisme = la capacité de changer

En programmation, le polymorphisme est une "technique" qui 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) à l'étudiant, vous pouvez probablement demander l'identification de l'étudiant. Vous ne pouvez pas toujours faire ça avec une personne, n'est-ce pas? (une personne n'est pas nécessairement un étudiant, donc peut ne pas avoir une carte d'étudiant). Cependant, une personne a probablement un nom. Un étudiant aussi.

En résumé, "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 des angles différents.

Pourquoi utilisons-nous le polymorphisme? Pour commencer ... l'abstraction. À ce stade, il devrait être assez d'informations :)




Le polymorphisme est la capacité à 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 qui hérite de Animal. Le polymorphisme est la capacité à traiter n'importe quel objet Chien comme un objet Animal comme ceci:

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



In Object Oriented languages, polymorphism allows treatment and handling of different data types through the same interface. For example, consider inheritance in C++: Class B is derived from Class A. A pointer of type A* (pointer to class A) may be used to handle both an object of class A AND an object of class B.




Utilisons une analogie. Pour un scénario musical donné, chaque musicien qui le joue donne son propre toucher à l'interprétation.

Le musicien peut être abstrait avec des interfaces, le genre auquel appartient le musicien peut être une classe abstrac qui définit certaines règles d'interprétation globales 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 «Fuga and Tocata» de Bach et chaque musicien qui l'exécute le fait de façon polymorphe à sa manière.

Ceci est juste un exemple d'une conception possible (en Java):

public interface Musician {
  public void play(Work work);
}

public interface Work {
  public String getScript();
}

public class FugaAndToccata implements Work {
  public String getScript() {
    return Bach.getFugaAndToccataScript();
  }
}

public class AnnHalloway implements Musician {
  public void play(Work work) {
    // plays in her own style, strict, disciplined
    String script = work.getScript()
  }
}

public class VictorBorga implements Musician {
  public void play(Work work) {
    // goofing while playing with superb style
    String script = work.getScript()
  }
}

public class Listener {
  public void main(String[] args) {
    Musician musician;
    if (args!=null && args.length > 0 && args[0].equals("C")) {
      musician = new AnnHalloway();
    } else {
      musician = new TerryGilliam();
    }
    musician.play(new FugaAndToccata());
}






Polymorphism is the ability to use an object in a given class, where all components that make up the object are inherited by subclasses of the given class. This means that once this object is declared by a class, all subclasses below it (and thier subclasses, and so on until you reach the farthest/lowest subclass) inherit the object and it's components (makeup).

Do remember that each class must be saved in separate files.

The following code exemplifies Polymorphism:

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

The father, a subclass:

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

The child, another subclass:

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

The execution method, references Parent class to start:

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

Note that each class needs to be declared in separate *.java files. The code should compile. Also notice that you can continually use maidenName and familyTree farther down. That is the concept of polymorphism. The concept of inheritance is also explored here, where one class is can be used or is further defined by a subclass.

Hope this helps and makes it clear. I will post the results when I find a computer that I can use to verify the code. Thanks for the patience!




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

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

Il y a beaucoup d'exemples ci-dessus qui montrent cela en action, mais je pense que c'est une bonne réponse concise.




I've provided a high-level overview of polymorphism for another question:

Polymorphism in c++

J'espère que cela aide. An extract...

...it helps to start from a simple test for it and definition of [polymorphism]. Consider the code:

Type1 x;
Type2 y;

f(x);
f(y);

Here, f() is to perform some operation and is being given the values x and y as inputs. To be polymorphic, f() must be able to operate with values of at least two distinct types (eg int and double ), finding and executing type-appropriate code.

( continued at Polymorphism in c++ )






Links