Syntaxe méthode hérité

bonjour,
débutant en java je me heurte à l'erreur suivante :
La méthode de la classe mère n'est pas appicable dans la classe fille.

Ma classe mère :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

public class Humain { // propriété int taille; int poids; //constructeur public Humain(){ taille = 0; poids = 0; } public Humain (int taille, int poids){ this.taille = taille; this.poids = poids; } public String parler(String nat) { return nat; }

---

ma classe fille:

Code:

---

1 2 3 4 5 6 7 8 9 10 11

public class Homme extends Humain { // propriété // constructeur hérité public Homme(int taille, int poids) { super(taille, poids); } public String parler(String nat){ //ICI est l'erreur super.parler(); } }

---

Merci de votre aide

La methode parler() (sans arguments) n'existe pas dans la classe mere.

Je pense que ce que tu voulais ecrire, c'est :

Code:

---

1 2 3

public String parler(String nat){ return super.parler(nat); }

---

salut,
je suis encore débutant alors je vais peut etre dire une betise mais si tu as posé ton code au complet il n'y a pas de main c'est normal ?
deuxieme chose j'ai l'impression que tu as deux méthodes "parler :

Citation:

---

public String parler(String nat) {
return nat;

---

et

Citation:

---

public String parler(String nat){
super.parler();

---

je ne sais pas si ca vient de la mais ca me parait bizarre :?

edit : lol grillé sur le fil par sanguko ;)
PS : tu pourrai peut etre m'expliquer ce que j'ai pas compris (ci dessus) ?

super.parler() te retourn un String
donc you are missing return super.parler() mais si tu va faire tu as juste a ne pas l override et ca fera ca.

Merci jhaythem, Sanguko

return super.parler(nat); //OK


Pour nayah, je me lance dans l'explication :
Ma classe Homme hérite de la classe Humain, dans cette dernière la méthode parler n'est pas abstraite donc le corps est déja défini, je n'ai qu'a l'utiliser tels quel dans ma classe humain (factorisation du code).

Citation:

---

Envoyé par totoche

Ma classe Homme hérite de la classe Humain, dans cette dernière la méthode parler n'est pas abstraite donc le corps est déja défini, je n'ai qu'a l'utiliser tels quel dans ma classe humain (factorisation du code).

---

je vois ce que tu veux dire mais il y a une chose que je comprends pas tu définis une premiere fois une méthode parler dans ta classe mere :

Citation:

---

public String parler(String nat) {
return nat;

---

et une seconde fois dans ta classe fille :

Citation:

---

public String parler(String nat){
super.parler();

---

si cette méthode étais abstraite je comprendrai pourquoi tu la défini une deuxieme fois mais la je seche... (dsl je suis un :boulet: c'est dans ma signature :aie: )

Salut,


totoche >> Tu confonds héritage et redéfinition.


Déjà dans ton code on peut lire ceci :

Code:

---

// constructeur hérité

---

Ce qui est complètement faux puisque les constructeurs ne sont pas hérités : chaque classe possède ses propres constructeurs (qui font appel aux constructeur de la classe parente).



Ensuite l'héritage consiste pour une classe fille a avoir directement accès aux méthodes de la classe parente. Donc tu n'as pas besoin de recoder parler() dans Humain :

Code:

---

1 2 3 4 5 6 7 8

public class Homme extends Humain {   // constructeur public Homme(int taille, int poids) { super(taille, poids); }   }

---

La méthode parler() sera quand même disponible :

Code:

---

1 2	Humain h = new Humain( ... ); String hello = h.parler("Hello");

---

Quand à la redéfinition d'une méthode (override en anglais), cela consiste à réécrire le code d'une méthode de la classe parente, éventuellement en la réutilisant pour modifier son comportement, par exemple tu pourrais faire quelque chose du style :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

class Homme extends Humain {   // constructeur public Homme(int taille, int poids) { super(taille, poids); }   @Override public String parler(String nat) { // On retourne la chaine entre quote : return " ' " + super.parler(nat) + " ' "; } }

---

:arrow: On a ici une redéfinition de la méthode parler(), qui modifie quelque peu son comportement d'origine et différencie un Humain d'un Homme...


a++

heu une derniere question AdiGuba parce que j'ai un peu de mal :koi: :

ca veut dire que j'avais raison de trouver ca bizarre ? :aie:

Citation:

---

Envoyé par nayah

ca veut dire que j'avais raison de trouver ca bizarre ? :aie:

---

Ben oui !

Ceci :

Code:

---

1 2 3

public String parler(String nat){ return super.parler(nat); }

---

Est totalement inutile dans ce cas précis, puisqu'on peut appeler directement la méthode parler() de la classe parente et que la redéfinition n'apporte rien de plus...


Le seul cas où ce genre de code est utile c'est lorsque la méthode parente n'est pas publique et que l'on veut élargir sa visibilité (par exemple si parler() étaient déclaré en protected dans la classe parente et qu'on souhaite la rendre visible à tous dans la classe fille).

a++

Bonjour,
effectivement présenté tel quel tu n'as pas besoin de redéfinir la méthode parler pour faire exactement la même chose que ce que fait la classe mère.
Tu surcharges la méthode seulement dans les cas suivant:

- si le traitement est différent

- si la méthode est déclarée abstract (si la classe mère est "abstract" ce n'est pas un problème si la méthode n'est pas déclarée abstract)

- si tu hérites la méthode d'une interface (mais dans ce cas on ne peux pas vraiment parler de surcharger la méthode)

Dans ton cas la surcharge a donc un intérêt si tu as

Code:

---

1 2 3 4 5 6

public String parler (String nat){ String s =super(nat); //traitement sur s; return s; }

---

par exemple. le super n'est même pas obligatoire.

bon code,
kerinel

edit : grillé...

ok c'est bien ce qui me sembler mais je suis pas encore a l'aise avec tout ca alors j'évite de trop m'avancer :roll:

Citation:

---

Envoyé par kerinel

Dans ton cas la surcharge a donc un intérêt si tu as

Code:

---

1 2 3 4 5 6

public String parler (String nat){ String s =super(nat); //traitement sur s; return s; }

---

---

C'est plutôt super.nomDeLaMethode et donc super.parler dans ce cas :

Code:

---

1 2 3 4 5 6

public String parler (String nat){ String s =super.parler(nat); //traitement sur s; return s; }

---

Citation:

---

Envoyé par kerinel

le super n'est même pas obligatoire.

---

Oui il l'est car sinon tu va rappeler la même méthode en boucle et non pas la méthode parente...

a++

"Et la lumière fut. " merci:hola:

La notion de constructeur héritée était un hérésie voulue:oops: un raccourci impropre pour me souvenir qu 'on peut faire appel aux constructeur de la classe parente... je ne commenterai plus ainsi...

Et quant à l'héritage d'une méthode sans parler override, je pensais qu'il fallait utiliser super, ce qui me parraissait contradictoire avec le concept d'héritage...

Merci encore pour ce recadrage très clair:P

Citation:

---

Envoyé par adiGuba

C'est plutôt super.nomDeLaMethode et donc super.parler dans ce cas :

Code:

---

1 2 3 4 5 6

public String parler (String nat){ String s =super.parler(nat); //traitement sur s; return s; }

---

---

effectivement

Citation:

---

Envoyé par adiGuba

Oui il l'est car sinon tu va rappeler la même méthode en boucle et non pas la méthode parente...

a++

---

Là je me suis mal exprimé: j'entendais par là que l'appel à la méthode parente n'est pas obligatoire. On peut très bien faire un traitement complètement indépendant et différent de ce qui ce fait la classe parente.

Code:

---

1 2 3 4 5 6 7

public class Bebe extends Humain { ... public String parler (String nat){ return new String("Areuh! "); } }

---

Par exemple ;)

désolé pour l'imprécision.

Bon code,
kerinel

Citation:

---

Envoyé par kerinel

Là je me suis mal exprimé: j'entendais par là que l'appel à la méthode parente n'est pas obligatoire. On peut très bien faire un traitement complètement indépendant et différent de ce qui ce fait la classe parente.

---

Heu oui bien sûr tu as raison on s'est mal compris ;)

a++