Discussion :

[kadilldév]

Bonjour j'ai consulté le polymorphisme dans le livre Programmer en Java(édition 5) dont la partie "Limites de l’héritage et du polymorphisme" dit:

la classe Point dispose d’une méthode identique fournissant la valeur true lorsque le point
fourni en argument a les mêmes coordonnées que le point courant :
Point p1, p2 ;
.....
p1.identique(p2) // true si p1 et p2 ont mêmes coordonnées
• la classe Pointcol, dérivée de Point, redéfinit cette méthode pour prendre en compte non
seulement l’égalité des coordonnées, mais aussi celle de la couleur :
Pointcol pc1, pc2 ;
.....
pc1.identique(pc2) // true si pc1 et pc2 ont mêmes coordonnées et même couleur
Considérons alors :
Point p1 = new Pointcol (1, 2, (byte)5) ;
Point p2 = new Pointcol (1, 2, (byte)8) ;

tous ça c'était une explication d'une redéfinition d'une méthodes se trouve dans la classe mère ce qui est normale pour moi ,mais le résultat qui m'étonne dont voici l’explication :

L’expression p1.identique(p2) a pour valeur true alors que nos deux points colorés n’ont pas
la même couleur. L’explication réside tout simplement dans la bonne application des règles
relatives au polymorphisme. En effet, lors de la compilation de cette expression p1.identique(
p2), on s’est fondé sur le type de p1 pour en déduire que l’en-tête de la méthode identique
à appeler était de la forme Point identique (Point). Lors de l’exécution, la ligature
dynamique tient compte du type de l’objet réellement référencé par p1 (ici Pointcol) pour
définir la classe à partir de laquelle se fera la recherche de la méthode voulue. Mais comme
dans Pointcol, la méthode identique n’a pas la signature voulue, on poursuit la recherche dans
les classes ascendantes et, finalement, on utilise la méthode identifie de Point. D’où le résultat
constaté.

je lie et je relie cette explication pas mal de fois et je comprends que lors de la compilation le choix de la méthode voulue s'est fais par rapport au type de la référence qui est de la classe mère (Point) mais lors de l’exécution la ligature dynamique n'arrive pas à choisir la méthode exacte par ce qu'elles n'ont pas la même signature

est ce que quelqu'un peut m'orienter vers la bonne compréhension (où améliorer la mienne )de cet exemple? merci d'avance pour votre attention .

[adiGuba]

Salut,


La réponse doit se trouver dans le code.
Je pense qu'ils ont voulu distinguer la redéfinition de la surcharge, ce qui peut provoquer des erreurs de compréhension :

• Redéfinition : même nom et même type de paramètre qu'une méthode de la classe parente.
• Surcharge : même nom, mais paramètre de type différent.

Par exemple si tu as une classe "Point" comme ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class Point {
    private final int x;
    private final int x;
 
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
 
    public boolean identique(Point p) {
        return this.x==p.x && this.y==p.y;
    }
}

Si tu définies ta class Pointcol comme ceci tu fait de la surcharge et non pas de la redéfinition :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Pointcol {
     private final byte col;
 
     public Pointcol(int x, int y, byte col) {
         super(x, y);
         this.col = col;
     }
 
     // Surcharge de méthode, car le type du paramètre change :
     public boolean identique(Pointcol p) {
           return super.identique(p)
               && this.col == p.col;
     }
}

En fait la classe Pointcol dispose alors de 2 méthodes nommées "identique" : identique(Point) héritée de la classe parente, et sa propre méthode identique(Pointcol).

Du coup si tu fais ceci :

Code :

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

1
2
3
4
5
Point p1 = new Pointcol (1, 2, (byte)5) ;
Point p2 = new Pointcol (1, 2, (byte)8) ; 
 
// Appel d'identique(Point)
p1.identique(p2)

Comme p1 est déclarée comme un "Point", le compilateur génère un appel vers la méthode identique(Point) de la classe Point.
A l'exécution, la JVM voit qu'il s'agit bien d'un type "Pointcol", mais ne trouve pas de redéfinition... justement parce que identique(Pointcol) n'est pas une redéfinition de identique(Point) !
Donc c'est bien la méthode de la classe "Point" qui est appélée.


Pour que la redéfinition fonctionne, il faut que la méthode utilise à la fois le même nom, mais également les mêmes types d'arguments.
L'annotation @Override permet de s'en assurer :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Pointcol {
     private final int col;
 
     public Pointcol(int x, int y, int col) {
         super(x, y);
         this.col = col;
     }
 
     // Redéfinition de méthode :
     @Override
     public boolean identique(Point p) {
           return super.identique(p)
               && (p instanceof PointCol)
               && this.col == ((PointCol)p).col;
     }
}

Là on a bien une redéfinition, et la méthode sera bien appelée même si l'instance de Pointcol est déclarée comme un Point.



Mais il reste quand même un problème à cela, c'est qu'on perd alors la symétrie de la méthode.
En effet en théorie si p1.identique(p2) on devrait avoir p2.identique(p1)... mais ce n'est plus le cas si on mélange des "Point" et des "Pointcol"...


a++

[kadilldév]

merci c'est très claire pour moi maintenant vive java