Search

Polymorphisme

 

Difficile

  1. Overloading (Méthodes & opérateurs)
    1. Method Overloading
    2. Operator overloading
  2. Overriding
    1. Method overriding

Dans la programmation orientée objet (POO),le polymorphisme permet de:

Donner différent sens ou usage à quelque chose en fonction du contexte.
Par exemple, permettre à une variable, à une fonction ou bien à un objet d'avoir plus d'une forme.

Le polymorphisme se manifeste sous 2 formes:
  1. Overloading (Méthodes & opérateurs)
  2. Overriding (Méthodes)

Overloading (Méthodes & opérateurs)

Method Overloading

Methods overloading signifie:
Avoir 2 méthodes (ou plus) portant le même nom dans la même classe mais avec des paramètres différents .
Prenons l'exemple suivant: 
def product(a, b):
    return a * b
 
def product(a, b, c):
    return a * b * c

product(2, 3)

>>>
---------------------------------------------------------------------------

TypeError  Traceback (most recent call last)

<ipython-input-3-878f6a0432c5> in <module>()
----> 1 product(2, 3)

TypeError: product() missing 1 required positional argument: 'c'




product(2, 3, 4)

>>> 24
Seule la dernière fonction est prise en compte. Cela signifie qu'on ne peut qu'avoir qu'une seule fonction avec le même nom.

Ainsi Python supporte-t-il vraiment l'overloading method ?
En fait, Python le supporte mais nous devons trouver une autre manière de l'exprimer.
Remarque:
En Java, le code au-dessus aurait marché correctement.
Un moyen d'y parvenir est d'utiliser *arg. 
def f(x, *argv):
    print("content of the variable x: ", x)
    for i in range(0, len(argv)):        
        print("elt {} in *argv : {} ".format(i, argv[i]))
        i += 1

f('hello', 'a', 'b', 'c')

>>>
content of the variable x:  hello
elt 0 in *argv : a 
elt 1 in *argv : b 
elt 2 in *argv : c 



f('1', '2')

>>>
content of the variable x:  1
elt 0 in *argv : 2
Ainsi, *argv nous permet d'avoir autant de paramètres que l'on veut. Ces derniers sont stockés dans une liste (*argv).
Revenons à notre exemple précédent avec product(). 
def product(*args):
    answer = 1
    for elt in args:
        answer = answer * elt
    return answer

print(product(2, 3))

>>> 6



print(product(2, 3, 4))

>>> 24

Operator overloading

Operator overloading signifie:
Ajouter de nouvelles fonctionnalités aux opérateurs pour qu'ils puissent être utilisé d'une autre manière.
Par exemple, l'opérateur + permet de faire une addition. Mais si on utilise l'overload, il peut être utilisé pour concatener des strings.

Voir exemple 4 dans le cours Méthodes spéciales - Magic/Dunder méthodes.

Overriding

Method overriding

Method overriding signifie:
Utiliser une méthode de la classe mère de manière différente dans la classe fille. 
class Parent(object):
    def __init__(self):
        self.value = 5

    def get_value(self):
        return self.value

class Child(Parent):
    def get_value(self):
        return 42

p = Parent()
print(p.get_value())

>>> 5



c = Child()
print(c.get_value())

>>> 42

Pour résumer:

Le polymorphisme permet de donner différent sens ou usage à quelque chose en fonction du contexte.
Ce dernier se manifeste sous 2 formes:
      1. Overloading (Méthodes & opérateurs)
      2. Overriding (Méthodes)