Discussion :

[DLOYAS]

bonsoir à tous,

dans le cas d'un héritage avec une redéfinition des méthodes comment est ce que java cherche la bonne méthode ? moi j'ai rien pigé!et c'est la raison derrière les questions suivantes :


soit A la classe mère de B :

question 1 : dans l'instruction A a = new B(); est ce cela veut dire qu'on ne crée dans a que la partie de B qui n'existe pas en A ?!

question 2 : A a = (B) b ;
c'est quoi la différence entre cette écriture et celle-ci :

Code :

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

1
2
3
4
 
A a = new A();
B b = new B();
a=b;

dans le cours le prof a écris que A a = (B) b n'est correcte que si la classe B est une sous-classe de A,(je comprends ça) mais il a ajouté que ( le type déclaré de b est une superclasse de B ) il est où le type déclaré de b dans l'instruction A a = (B) b ? (mes questions sont stupides? desolé mais je viens de commencer le cours)

3 ème question : recherche de la méthode à exécuter :
soit le code suivant :

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
17
18
19
20
21
22
23
24
25
 
class A{
  void m(A a){
    System.out.println("m de A");
  }
  void n(A a){
    System.out.println("n de A");
  }
}
 
 
class B extends A{
  void m(A a){
    System.out.println("m de B");
  }
  void n(B b){
    System.out.println("n de B");
  }
  public static void main(String[] argv){
    A a = new B();
    B b = new B();
    a.m(b);
    a.n(b);
  }
}

qu'est ce qu'affichera l'exécution de la méthode main de B ?

Réponse:

m de B
n de A

pourquoi ce choix de méthodes ?

[DLOYAS]

voilà la procédure trouvée sur le net :
Pour le premier envoi de message a.m(b) :
– etape ´ 1 : la classe ou` chercher la methode ´ est celle declar ´ ee´ pour a, c’est a` dire A.
– etape ´ 2 : il n’y a qu’une methode ´ de nom m dans A. Elle a pour type A → void.
– etape ´ 3 : le type fixe´ est A → void.
– a` l’execution, ´ la recherche de la methode ´ m de type A → void se fait dans le type le plus petit
ou type d’instance de a, c’est a` dire B. Il y a la` la methode ´ m de B qui a le bon type. C’est elle
qui est execut ´ ee. ´
Pour le deuxieme ` envoi de message, a.n(b) :
– etape ´ 1 : la classe ou` chercher la methode ´ est celle declar ´ ee´ pour a, c’est a` dire A.
– etape ´ 2 : il n’y a qu’une methode ´ de nom n dans A. Elle a pour type A → void.
– etape ´ 3 : le type fixe´ est A → void.
– a` l’execution, ´ la recherche de la methode ´ n de type A → void se fait dans le type le plus petit
ou type d’instance de a, c’est a` dire B. La methode ´ n de B ne convient pas, car elle n’a pas le
bon type. La methode ´ n de A convient. Elle a le bon type et elle est presente ´ dans la classe B
par heritage. ´ C’est elle qui est choisie.
Merci..

[tchize_]

question 1 : dans l'instruction A a = new B(); est ce cela veut dire qu'on ne crée dans a que la partie de B qui n'existe pas en A ?!

Non, ça veux dire exactement ce qui est écrit: on crée un B et on stocke sa référence dans une variable appelée a.

question 2 : A a = (B) b ;
c'est quoi la différence entre cette écriture et celle-ci :

Code :

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

1
2
3
4
 
A a = new A();
B b = new B();
a=b;

Dans le deuxième cas on a créé un A que l'on a jeté tout de suite, et qui ne sert à rien puisqu'il est remplacé dans la variable a par la référence au nouveau B() créé juste avant

dans le cours le prof a écris que A a = (B) b n'est correcte que si la classe B est une sous-classe de A,(je comprends ça) mais il a ajouté que ( le type déclaré de b est une superclasse de B ) il est où le type déclaré de b dans l'instruction A a = (B) b ? (mes questions sont stupides? desolé mais je viens de commencer le cours)

Il n'est pas dedans, il se situe avant, sous la forme, par exemple

Code :

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

1
2
3
4
Object b; //le type déclaré est Object
B b; // le type déclaré est B
ou
Tartempion b; // le type déclaré est Tartempion

D'ailleurs ton prof omet un cas bien que franchement faut être con pour typecaster dans ce cas là car c'est inutile:

le type déclaré de b est une superclasse ou une sous classe de B

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
17
18
19
20
21
22
23
24
25
 
class A{
  void m(A a){
    System.out.println("m de A");
  }
  void n(A a){
    System.out.println("n de A");
  }
}
 
 
class B extends A{
  void m(A a){
    System.out.println("m de B");
  }
  void n(B b){
    System.out.println("n de B");
  }
  public static void main(String[] argv){
    A a = new B();
    B b = new B();
    a.m(b);
    a.n(b);
  }
}

qu'est ce qu'affichera l'exécution de la méthode main de B ?

Le choix se fait en deux étapes. A la compilation on détermine les signatures de méthodes, à l'exécution on détermine la méthode réelle correspondant aux signature. La première étape utilise les types déclarés, la secondes les type actuels

A est le type déclaré, il a deux méthode: m(A) et n(A), le code est donc traduit par le compilateur en un truc du genre


a.m_A(b); //appeler m(A) sur l'instance a avec le paramètre l'instance b
a.n_A(b);//appeler n(A) sur l'instance a avec le paramètre l'instance b


a l'exécution, a référence une instance de type B. On cherche donc sur B une méthode m_A et une méthode n_A. m_A est bien redéfini dans B, mais n_A n'existe que dans le parent A

pour dire autrement, dans B, ta méthode m est une redéfinition de la méthode m de A, car elle a les même paramètres, mais ta méthode n est une nouvelle méthode, distincte de celle présente dans A car les paramètres sont différents.

[DLOYAS]

Merci cher Ami,

pour A a = (B) b on a declaré une reference de type B et on l' a stocké dans une réference a de type A ?
pour
@Ttchize_ : ( Non, ça veux dire exactement ce qui est écrit: on crée un B et on stocke sa référence dans une variable appelée a )

une variable appelée a [ de type A ],c'est ça je que tu voulais dire bien sûr ... ?

@Ttchize_ :
( D'ailleurs ton prof omet un cas bien que franchement faut être con pour typecaster dans ce cas là car c'est inutile )

il a ajouté que ( le type déclaré de b est une superclasse de B ),je trouve ça un peu logique, je pense qu'il parlait de ce cas la :

Code :

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

1
2
3
4
 
Forme f = new Ce r c l e ( ) ;
Ce r c l e c = ( Ce r c l e ) f ; // le type declaré de f est Forme, il est une superclasse de Cercle 
Ca rr e r = ( Ca rr e ) f ;

pourquoi la conversion

Code :

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

 Ca rr e r = ( Ca rr e ) f

conversion provoque une erreur ?





merci beaucoup pour ton explication

[tchize_]

Merci cher Ami,

pour A a = (B) b on a declaré une reference de type B et on l' a stocké dans une réference a de type A ?

Non, on a déclaré plus avant une variable (on ne déclare pas vraiment une référence, une référence c'est juste une valeur) appelée b de type que je ne connais pas puisque je n'ai pas le code qui va avec. On a déclaré aussi une variable a de type A. On prend la référence stockée dans b, on vérifie qu'elle est bien du type B et on copie cette référence dans a.

une variable appelée a [ de type A ],c'est ça je que tu voulais dire bien sûr ... ?

Oui la variable est déclaré de type A.


@Ttchize_ :
( D'ailleurs ton prof omet un cas bien que franchement faut être con pour typecaster dans ce cas là car c'est inutile )

il a ajouté que ( le type déclaré de b est une superclasse de B ),je trouve ça un peu logique, je pense qu'il parlait de ce cas la :

Code :

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

1
2
3
4
 
Forme f = new Ce r c l e ( ) ;
Ce r c l e c = ( Ce r c l e ) f ; // le type declaré de f est Forme, il est une superclasse de Cercle 
Ca rr e r = ( Ca rr e ) f ;

Oui, je te te signale juste que ce code aussi est valide:

Code :

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

1
2
3
 
Cercle c = new Cercle ();
Objet o = (Forme)c;

Cercle n'est pas une superclasse de Forme, mais le typecasting reste valide, bien qu'inutile

pourquoi la conversion

Code :

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

 Ca rr e r = ( Ca rr e ) f

conversion provoque une erreur ?

Il provoque une erreur à l'exécution. La compilation se passera sans problème, le type déclaré "Forme" est bien un supertype de Carre. Par contre, a l'exécution, la jvm va se retrouve avec f qui contient un Cercle, un Cercle ce n'est pas une Carre, il y a donc une erreur. Le typecasting ne sert qu'à indique au compilateur ce que tu t'attends à trouver comme objet. Il ne transforme pas l'objet. Un Cercle ne va pas magiquement devenir un Carre.

[DLOYAS]

je te remercie infiniment tchize_

[adiGuba]

Salut,


Juste une remarque complémentaire vis à vis du code initial de la classe B :

• La méthode m(A) de B est bien une redéfinition de la méthode m(A) de A (ce qui fait que c'est bien la méthode du type réel qui est appelée).
• Par contre la méthode n(B) de B n'est pas une redéfinition de la méthode n(B) de A puisque les paramètres diffèrent ! Il s'agit en fait d'une surcharge (même nom mais paramètres différents).

On peut le voir en rajoutant l'annotation @Override sur ces méthodes : cela génèrera une erreur pour la méthode n(B)...


Malgré leurs noms identiques, pour la JVM il n'y a aucun rapport entre n(A) et n(B).
Elles pourraient très bien avoir des noms différents...



a++

[DLOYAS]

Mes amis, j'ai appliqué la procédure de recherche de la méthode à executer, mais elle m'a pas donné les mêmes resultats que ceux du compilateur, je commence à stresser

svp,mon raisonnement ici sur cet exemple, il est juste ?
je n'oublierai jamais l'aide apporté :

la classe Etudiant hérite de Personne :

Code :

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

1
2
3
 
class Personne {
int f ( Personne p ) { return 1 ;} }

Code :

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

1
2
3
4
5
 
class Etudiant extends Personne { 
int f ( Personne p ) { return 2 ;}
int f ( Etudiant p2 ) { return 3 ;}
}

et

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
17
18
19
20
21
22
23
24
25
26
27
 
Personnne a = new Personne () ;
Personne ab = new Etudiant () ;
Etudiant b = new Etudiant ; 
 
// partie 1
 
System.out.println (a.f(a)); // cet appel est simple il va retourner 1
System.out.println (a.f(ab));// le type declaré de a est A je cherche dans A la méthode qui a le même nom ( et le nombre d'argument )  que celle que            j'appelle,dans mon cas
                                      //  c'est  f ( Personne p ), je cherche dans le type d'instance de a une fonction qui a le (même) nom et paramètres  (ou avec des paramètres de super  classe)..dans ce cas la il n'ya rien autre que la fonction qui retourne 1 .
 
 
System.out.println (a.f(b)); //  le même raisonnement que celui d'avant .
 
// partie 2
 
System.out.println (ab.f(a));// le type declaré de (ab) est personne ,je cherche dans la classe  personne une méthode qui a le même nom ( nombre de paramètre) que celle que j'appel.. c'est donc  f( personne p), je cherhce dans le type d'instance de ab, les fonction qui ont le même nom,le même nombre de paramètres et les pramètres, c'est donc la fonction qui retourne 2. 
System.out.println (ab.f(ab); // le même raisonement, il donne  2 
System.out.println (ab.f(b));// même raisonnement, il donne 2 .
 
// partie 3
 
// même raisonnement :
 
System.out.println (b.f(a));// il donne 2
System.out.println (b.f(ab));// donne 2
System.out.println (b.f(b)); // donne 3

mon raisonnement est juste ?

[tchize_]

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
17
18
19
20
21
22
23
24
25
26
27
 
Personnne a = new Personne () ;
Personne ab = new Etudiant () ;
Etudiant b = new Etudiant(); 
 
// partie 1
 
System.out.println (a.f(a)); // OK cet appel est simple il va retourner 1
System.out.println (a.f(ab));// OK le type declaré de a est A je cherche dans A la méthode qui a le même nom ( et le nombre d'argument )  que celle que            j'appelle,dans mon cas
                                      //  c'est  f ( Personne p ), je cherche dans le type d'instance de a une fonction qui a le (même) nom et paramètres  (ou avec des paramètres de super  classe)..dans ce cas la il n'ya rien autre que la fonction qui retourne 1 .
 
 
System.out.println (a.f(b)); // OK  le même raisonnement que celui d'avant .
 
// partie 2
 
System.out.println (ab.f(a));// OK le type declaré de (ab) est personne ,je cherche dans la classe  personne une méthode qui a le même nom ( nombre de paramètre) que celle que j'appel.. c'est donc  f( personne p), je cherhce dans le type d'instance de ab, les fonction qui ont le même nom,le même nombre de paramètres et les pramètres, c'est donc la fonction qui retourne 2. 
System.out.println (ab.f(ab); // OK le même raisonement, il donne  2 
System.out.println (ab.f(b));// OK même raisonnement, il donne 2 .
 
// partie 3
 
// même raisonnement :
 
System.out.println (b.f(a));// il donne 2
System.out.println (b.f(ab));// donne 2
System.out.println (b.f(b)); // donne 3  b est déclaré Etudiant, ont cherche une méthode f prenant un Etudiant. Le type réel de l'appel est Etudiant, donc c'est bien 3 qui sera retourné.

mon raisonnement est juste ?

Oui juste (cf mes commentaires) qu'est ce que tu constate qui te pose soucis?

[DLOYAS]

je viens de lire ta question, En fait c'est le transtypage qui me pose des problèmes, je ne le comprends pas bien! les trucs entre parenthèse je ne comprends pas toujours leur sens : ))

je ne veux pas trop abuser de ta gentillesse mais par exemple :

Code :

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

1
2
3
4
5
6
 
class A { 
int i =1 ; 
int f() { return i; } 
public static int g() { return (6) ; }
}

et

Code :

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

1
2
3
4
5
 
class B extends A 
{ int i=2;
int f() { return super().f()*3+i;}
public static int g() { return (7) ; } }

la question qui avait posé le prof est : dans B,si on remplace super().f() par ((A)this).f() quelle est la méthode appelée ?! meme question pour ((A)this).i au lieu de ((A)this).f() ?

si j'aurai cette question le jour de l'examen je dirai : super().f() est éuivalente à ((A)this).f(), il va donc appeler f() de la classe A, pour ((A)this).i il va appelr le i de la classe A . ceci est jute ?

question 1 :
et dans le main :

B b = new B ();
A a = b ;
system.out.print( a.f()*a.g() ) ; qu'est ce qu'elle va afficher ?


normalement g() est static,donc pas de redéfinition de la méthode, il va donc et dans tout les cas appeler g() de la classe mère ? En revanche pour a.f() c'est f() de la classe B qui sera appelé, ai -je raison ?

[tchize_]

si j'aurai cette question le jour de l'examen je dirai : super().f() est éuivalente à ((A)this).f(), il va donc appeler f() de la classe A, pour ((A)this).i il va appelr le i de la classe A . ceci est jute ?

As-tu testé?


super est un mot clé spécial qui permet à une classe de référencer quelque chose dans son parent qui normalement est inaccessible. Il sert dans une classe à résoudre le problème de pouvoir déléguer le travail à une méthode du parent qui a été redéfinie dans l'enfant. Normalement, cette méthode du parent deviens inaccessible de par le principe de redéfinition. Mais dans le cas particulier de la classe enfant, il est normalt que l'enfant aie besoin d'accéder au comportement du parent pour le modifier. Donc dans ce cas, et uniquement dans ce cas, le language nous autorise à acceder à la définition précédente, via le mot clé super. Cela n'a rien à voir avec le type casting. Il ne faut donc pas vois super comme un type casting, mais comme une mot clé permettant de contourner les redéfinitions.

Code :

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

((A)this).f()

se comporte exactement de la même manère que si on appelait f de l'extérieur. Les règle de résolution déjà évoquées s'appliquent toujours. On cherche une méthode f() dans this, ce qui tombe dans la redéfinition en B. En fait le typecasting ne change rien et tu as un appel récursif infini sur f.

Pour ((A)this).i c'est différent. Les champs ne se surchargent pas et ne se redéfinissent pas. On accède bien au i du parent, mais c'est vraiement une manière inutilisée en général En général on évite de cacher un champ hérité en en créeant un nouveau du même nom.

normalement g() est static,donc pas de redéfinition de la méthode, il va donc et dans tout les cas appeler g() de la classe mère ? En revanche pour a.f() c'est f() de la classe B qui sera appelé, ai -je raison ?

Oui.

Note que tu aurais les réponses à toutes ces questions si tu tappait ces code dans une ide et que tu regardais ce qui sort

[DLOYAS]

donc dans ce cas la

Code :

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

1
2
 
((A)this).f(); // ici on a pas forcer le compilateur à prendre le type (A) de b non (B) ?

est équivalent à :

Code :

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

1
2
 
((B)this.f();

pouvez vous m'expliquer stp comment dois-je lire une instruction comme celle ci :

((X) alpha).f() ; ? // ce n'est pas faire appel à f de alpha, en prenant le type (X) de alpha,non le type decalaré ?

[tchize_]

((X) alpha).f() ; ? // ce n'est pas faire appel à f de alpha, en prenant le type (X) de alpha,non le type decalaré ?

C'est excatement le même comportent au final que

Code :

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

1
2
X x = (X) alpha;
x.f();

A la compilation: On recherche une méthode f sur X. on note que l'on appelera void f() sur x
A l'exécution, on regarde le type réel de x, et on y cherche la méthode void f(), qui peut très bien avoir été redéfinie dans l'instance.

Je crois que tu dois oublier l'idée que l'appel se faire sur une type déclaré ou autre, t'es occupé de t'embrouiller inutilement.

Tu a deux choses qui existent en objet: la redéfinition et la surcharge.

redéfinition: même nom de méthode, même paramètres. La méthode dans l'enfant se substitue à la méthode du parent et rends la méthode du parent inaccessible (à l'exception du mot clé super). La rédéfinition n'existe que pour des méthodes non privées et non statique.
surcharge: même nom de méthode, paramètres différents en nombre ou en type. La méthode n'a rien à voir avec celle qu'elle surcharge, elles sont appelables indépendamment.


Le type déclaré d'une variable sert au compilateur à distinguer entre les différentes surcharges possible d'une méthode. Typecaster vers un enfant permet éventuellement au compilateur d'avoir le choix entre plus de surcharges ou de voir de nouvelles méthodes. Typecaster vers un parent, ou utiliser un type déclaré parent pour stocker la référence, permet au contraire de limiter ce que voix le compilateur et donc d'exclure certains surcharges.

[DLOYAS]

(Y) Merci beaucoup cher ami!
j'ai bien compris ...