Discussion :

[LIANAZEL]

Bonjour,


Je me mélange un peu ces deux concepts de la POO, la différente ne m'est pas evidente.


Je veux bien que quelqu'un m'explique en deux mots la différence !


J.C

[theMonz31]

Surcharge ==> Avoir une même méthode qui possède des paramètres de nature différentes...

Genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
void Message(string a);
void Message(int a);
void Message(string a, string b);

La redéfinition se passe dans le cas d'un héritage et plutôt que d'utiliser la méthode du parent on va redéfinir la méthode (en utilisant la même signature).

[LIANAZEL]

Bonjour,


Dans ton exemple, s'agit-il de la même méthode, ou bien de méthodes différentes ayant le même nom mais avec des paramètres différents ?



J.C

[Math71]

c'est le meme nom de méthode avec des parametres différents mais la fonction fait la meme chose

[LIANAZEL]

Donc c'est une seule et même méthode ??

[Math71]

la surcharge c'est soit une méthode qui acceptes plusieurs paramètres

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
void Message(int a)
void Message(int a, int b)

soit une méthode qui acceptes plusieurs types de parametre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
void Message(int a)
void Message(string b)

c'est juste que la méthode tu peux l'appeller de différentes facon !

la redéfinition c'est une methode qui existe dans la classe Mère mais que tu veux modifier

[LIANAZEL]

Ok, merci.

Je commence à y voir plus clair

[Sehnsucht]

Version courte :
La surcharge c'est quand on veut "faire la même chose" peu importe les arguments donnés
La redéfinition c'est quand on veut "faire la même chose" peu importe le type dans lequel on est dans la hiérarchie

Version moins courte :
La surcharge c'est avoir plusieurs méthodes d'une même classe avec des signatures différentes ; cela permet de définir le même comportement pour des entrées (arguments) différents.
La redéfinition c'est d'avoir une méthode dans une classe "fille" qui "adapte" (pour pas utiliser redéfinir) un comportement hérité de sa classe "parent" à ses spécificités.

Exemples
-----------

Pour la surcharge :
J'ai une classe Point avec une méthode pour calculer la distance entre le point courant et un autre point, faire double Distance (Point p) fonctionne ; sauf qu'après réflexion je me dis, c'est embêtant de devoir à chaque créer un objet Point pour pouvoir le passer en argument ; donc j'écris une nouvelle version de la méthode Distance dans la même classe qui prend maintenant en argument ses coordonnées double Distance (int x, int y) et maintenant j'ai le choix; si j'ai déjà un objet Point de créé je peux utiliser la première surcharge, sinon je peux utiliser la seconde en donnant juste les coordonnées.

Note : souvent dans ce type de cas de figure les différentes surcharges appellent une même méthode (potentiellement une des surcharges ou une méthode privée) qui elle s'occupe du boulot concret ce qui peut donner ici :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
class Point
{
    public double Distance (Point other)
    {
        return Distance (other.X, other.Y);
    }
 
    public double Distance (int x, int y)
    {
        // un calcul
    }
}

Ça permet d'éviter de mettre le code de calcul en double


Pour la redéfinition :
Imaginons que l'on ait fait une classe Bouton qui représente un bouton sur une interface ; il a plein de méthodes dont une qui permet de dire comment le dessiner au "truc" qui gère le rendu. Maintenant on fait une classe BoutonPoussoir qui est un bouton particulier dans le sens où au premier clic il reste enfoncé au second il reprend son état initial etc. Donc sa manière de se dessiner est différente (il faut le représenter enfoncé où non selon l'état).
Du coup il faut pouvoir redéfinir la manière de dessiner ; pour cela il faut que Dessiner dans Bouton soit redéfinissable (virtual en C#) et dans BoutonPoussoir on redéfinira (override en C#) la méthode mais on ne change pas la signature de la méthode (même nombre et types d'arguments).

Ça sert par exemple lorsque l'on a une liste de bouton qui contient différents type de Bouton (donc ici des Bouton et des BoutonPoussoir) et qu'on veut que chacun se dessine on va boucler sur la liste et appeler la méthode Dessiner de chacun et ce sera la bonne méthode qui sera utilisée pour chaque type de bouton (Bouton.Dessiner pour les instances de Bouton et BoutonPoussoir.Dessiner pour les instances de BoutonPoussoir).

[acaunensis]

la surcharge c'est soit une méthode qui acceptes plusieurs paramètres

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
void Message(int a)
void Message(int a, int b)

soit une méthode qui acceptes plusieurs types de paramètre

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
void Message(int a)
void Message(string b)

c'est juste que la méthode tu peux l’appeler de différentes facons !

la redéfinition c'est une méthode qui existe dans la classe Mère mais que tu veux modifier

-> comme c'est déjà précisé plus haut : penser à la signature:
-> la surcharge est une fonction de même nom, qui fait (normalement) la même chose mais avec une signature différente (pas les même paramètres ou pas dans le même ordre).
-> la redéfinition se passe dans une classe fille, la fonction redéfinie possède la même signature

selon wiki :
surcharge = polymorphisme ad hoc = overloading
redéfinition = polymorphisme d'inclusion = overriding