Discussion :

[BOLARD]

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

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
28
 
     // 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 ...........}
}
 
 
class ImprimerFonction
{
     ImprimerFonction();
     double calculer(double x) {return 0;}
     void lister();
}

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 :

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

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 :

Code :

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

1
2
 
double calculer(double x)

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.

Désolé pour la longueur du message.

Merci pour votre aide

dav79

[pverley]

Bonjour,

Classe abstraite dans Thinking in Java :

If you inherit from an abstract class and you want to make objects of the new type, you must provide method definitions for all the abstract methods in the base class. If you don't (and you may choose not to), then the derived class is also abstract, and the compiler will force you to qualify that class with the abstract keyword.

Ce que tu veux faire n'est pas possible je pense.
De tout façon, si ta classe ImprimerFonction hérite de FonctionNommee et qu'elle n'a pas besoin de redéfinir la seule méthode abstraite calculer, c'est que la conception est mal pensée au départ...

A +
Philippe.

[bulbo]

Je rejoins pverley pour le problème de conception.

Par contre ce que tu peux faire dans ton cas, c'est de définir la méthode calculer dans ta classe abstraite, hé oui ce n'est pas parce que la classe est abstraite que toutes les méthodes doivent l'être.

L'implémentation par défaut de calculer enverra une runtime exception genre NotSupportedException et les classes supportant calculer doivent redéfinir la méthode. Tu précises ça dans la javadoc histoire que ça soit clair et roule.

Sinon change ton design, crée peut-être une interface pour certaines méthodes et une classe abstraite ou une autre interface pour d'autres en respectant la logique de ton application et en regroupant seulement ce qui doit l'être.

Bulbo

[fabszn]

Hello,

Je rejoins l'avis général concernant le problème de conception.

Quel est le rôle de la classe ImprimerFonction?

Est ce que cette classe à pour but d'imprimer une fonction de type FonctionNommee?

[BOLARD]

Je suis tout a fait d'accord avec vous, la conception me semble pas bonne, mais en fait ce n'est pas moins qui est définit les classes ou la logique de l'exercice, je suis juste un cas d'école, pour étudier comment fonctionnement las classes abstracts et sous-classes ainsi que l'héritage.


Je rappel rapidement mon souci. J'ai trois classes :

- 1 class abstract FonctionNommee qui deux méthodes :
-- abstract calculer()
-- void imprimer(double x) {...................}

- 1 class CosMoinsNommee() : sous-class de FonctionNommee
-- le constructeur
-- méthode redéfinit calculer(double x) {...................}

- 1 class ImprimerFonction sous-classe FonctionNommee a deux méthodes
--- Constructeur
--- void lister(){................}
-- calculer // Car je suis obligé de redéfinir cette méhode,

La classes ImprimerFonction ne peut être déclaré en abstract car la méthode lister() n'est pas une méthode abstract, c'est bien là le problème.

Au départ je n'avais pas mis la méthode calculer dans la classe ImprimerFonction, mais le compilateur ne l'accepte pas, puisque que la classe ImprimerFonction est une sous-classe de la classe FonctionNommee, on doit obligatoirement redéfinir les méthodes abstract dans les classes filles. Et donc ici je doit redéfinir calculer() dans les sous-classes CosMoinsNomme et ImprimerFonction.

Moi je souhaiterai redéfinir calculer uniquement dans CosMoinsNomme, comment faire pour faire comprendre au compilateur qu'il n'est pas nécessaire de rédifinir calculer dans la class ImprimerFonction, tout en tenant compte que la classe ImprimerFonction doit être une sous-classe de class FonctionNommee.

C'est pourquoi j'ai parlé d'annotation comme par exemple @override, je crois que cette instruction veut dire que le compilateur ne tient pas tenir compte de la redéfinition de la méthode de la classe parent.

Est ce que c'est envisageable techniquement notamment avec les annotation, je ne vous parle pas au niveau de la conception, je pense que oui

Je vous remercie par avance pour vos solutions

dav79

[verbose]

La réponse t'as déjà été donnée, mais je vais essayer de te faire comprendre pourquoi.

Supposons que tu aies une classe AppareilElectromenager avec deux fonction allumer() et éteindre(). D'autre part tu veux écrire une classe Aspirateur et une classe ReveilMatin. Jusque là rien de bien compliqué.

Cependant, si il est naturel de pouvoir allumer et éteindre un aspirateur, je te défi de trouver un bouton permettant d'éteindre un réveil-matin. On peut éteindre la sonnerie d'un réveil, mais pas le réveil lui-même, ce qui n'a pas la même signification d'un point de vue sémantique, ni du point de vue de l'implémentation.

Par conséquent, il y a deux possibilités :
1) Soit la classe ReveilMatin ne doit pas hériter de la classe AppareilElectromenager
2) Soit on veut absolument faire hériter ReveilMatin de AppareilElectromenager. Dans ce cas la classe AppareilElectromenager ne doit pas déclarer les méthodes allumer() et éteindre() puisqu'elles ne sont pas communes à toutes les sous-classes.