Bonjour, voilà je suis entrain d'étudier les classes abstract, mais je rencontre un probème, ou je suis un peu bloqué, j'ai regardé un peu sur les FAQ, mais je n'est pas trouvé la solution vraiment à mon problème, qui est le suivant :
J'ai trois classes : une classes abstract et deux classe qui hérite de la classe abstract
- abstract class FonctionNommee
- class CosMoinsNommee
- class ImprimerFonction
Voici la composition de ces classes en gros
[QUOTE]
// Classe FonctionNommee
abstract class FonctionNommee
{
String nomFonction;
abstract double calculer(double x);
void imprimer() {.......Corps du code.....;}
}
// Classe CosMoinsNommee
class CosMoinsNommee
{
String nomFonction
//Constructeur
CosMoinsNomme(String nomFonction){............}
// Méthode redéfinit
double calculer(double x) {.......... Corps du code ...........}
}
Donc en fait, j'ai compilé la classes FonctionNomme et la CosMoinsNommee, pas de problème jusque là
Par contre lorsque que j'ai compilé la clase ImprimerFonction, le problème c'est posé.
D'après la documentation que j'ai consulté quand on utilise une classe abstract pour toutes les méthodes abstract de cette classe doivent être redédéfinit dans les sous-classes de la classes abstract.
Et donc cela signifie que dans cette exemple qu'il faut absolument que je redéfinisse la méthode calculer() à la fois dans la classe CosMoinsNomme et dans la classe ImprimerFonction.
C'est là le problème, je souhaiterai redéfinir cette méthode uniquement dans la classe CosMoinsNomme car c'est uniquement dans cette classe que je rédéfinit calculer.
Si je déclare uniquement la fonction calculer dans la classe ImprimerFonction en abstract, il me met se message :
[QUOTE]
Math/ImprimerFonction.java:4: Math.ImprimerFonction is not abstract and does not
override abstract method calculer(double) in Math.ImprimerFonction
class ImprimerFonction extends FonctionNommee
^
1 error
[/QUOTE]
Cela signifie que ma classe ImprimerFonction n'est pas abstract, donc aucune méthode de cette classe ne peut être mis en abstract.
si je met le corps met rien à l'intérieur du corps de cette fonction, il me dit que j'ai oublié le return car la signature de la méthode calculer est la suivante :
[QUOTE]
double calculer(double x)
[/QUOTE]
Donc ce que j'ai fait pour contourner le problème j'ai mis return 0 dans le corps de la fonction, est ce qu'il aurait un autre moyen pour résoudre ce problème, je souhaiterai que le compilateur ne prenne en compte la rédéfinition de la méthode calculer dans la classe ImprimerFonction, avec des anotations par exemple, je pense que ça doit être possible, je pensais que ça allait marché avec @override, mais j'ai pas bien compris le principe peut être aussi que ça dépend des version JDK, Moi j'ai la version 6.0....
j'espère que j'ai été claire dans l'explication, n'hésiter pas à me demander des précisions.
je ne connais pas très bien la dernière version du JDK, mais à mon avis le problème est surtout un problème de logique beaucoup plus général.
Quand on définit une classe abstract, les fonctions abstraites doivent forcément être définies par toutes les classes filles ; c'est la raison d'être même d'une classe abstraite : on doit pouvoir manipuler ses instances en étant sûr que si l'on appelle maVariable.calculer(1, 2) la fonction soit bien définie, peut importe la classe qui redéfinit réellement la fonction.
Donc, je vois trois cas possible (au niveau de la logique) :
-Soit la méthode calculer() n'est pas générale à toutes les classes de type FonctionNommee et donc ne doit pas être abstraite.
-Soit la classe ImprimerFonction ne peut pas être considérée comme une FonctionNommee et ne devrait pas étendre la classe FonctionNommee.
-Soit la classe ImprimerFonction décrit un sous-ensemble de FonctionNommee, et qu'elle est destinée à être redéfinie. Auquel cas il faut la déclarer abstraite, mais tu ne pourras plus t'en servir directement : tu seras obliger de faire une classe qui l'étend et qui redéfinit bien la méthode calculer().
En aucun cas tu peux étendre cette classe sans redéfinir une méthode abstraite, encore une fois je me répète, mais c'est une question de logique de conception.
Le compilateur doit pouvoir garantir que le code suivant marche dans tout les cas :
public void appelerCalculer(FonctionNommee f)
{
//or ici, on ne sait pas du tout de quel type est précisément f
//elle peut être n'importe quelle classe fille de FonctionNommee
//donc si on étend FonctionNommee sans redéfinir calculer()
//que se passerait-il ici ? il y aurait un problème...
System.out.println("Résultat : " + f.calculer(1,3));
}
voila, @++ et bonne prog !
__________________________
Lorsque touts les arbres auront été coupés, Lorsque touts les animaux auront été chassés, Lorsque touts les poissons auront été pêchés;
Alors l'homme découvrira que l'argent ne se mange pas.
------ |_o/e _|a/a---------