Discussion :

[Astro-Péptio]

Bonjour à tous,


J'ai une structure de classes très simple du type ClassA <--- ClassB <--- ClassC. J'aimerais pouvoir utiliser un objet de cette arborescence mais dont je ne connais pas précisément le type : il peut s'agir d'un ClassB ou ClassC (ClassA est abstraite). La seule chose que je sais, c'est qu'il est dans cette arborescence et hérite de ClassA. Pour savoir quel type d'objet je dois créer, je regarde la première ligne d'un fichier de configuration.
Cet objet est ensuite stocké en tant qu'attribut dans une "classe chapeau" pour être réutilisé dans d'autres classes. Il faut donc que je sache quel type je dois donner à l'objet dans la classe chapeau ce qui, si vous avez bien suivi, dépend de la première ligne de mon fichier de configuration.

Le problème est que je ne sais pas comment typer cet objet.
Je ne peux pas utiliser de polymorphisme (ClassA monObjet = new ClassB() par ex) car j'ai besoin d'avoir accès aux attributs de la classe enfant.

Auriez-vous une solution à me proposer ?


Merci d'avance pour votre aide !

[jroman]

Je ne crois pas que tu puisse appliquer le polymorphisme à un constructeur, j'aurais plus pensé que c'était reservé aux fonctions membres et interdit aux fonction amies.
Si j'ai bien compris ton soucis, tu lis dans un fichier de conf, et selon ce qui est écris tu souhaite crée un objet classeB ou classeC ?

[Astro-Péptio]

Oui, je voudrais créer un objet du bon type et, surtout, je veux le stocker dans un objet "générique" qui accepte tous les sous-types possibles (ClassB et ClassC) mais qui me permet tout de même d'accéder aux attributs spécifiques à la classe en question (d'où l'impossibilité d'utiliser un objet ClassA).

[Robin56]

Oui, je voudrais créer un objet du bon type et, surtout, je veux le stocker dans un objet "générique" qui accepte tous les sous-types possibles (ClassB et ClassC) mais qui me permet tout de même d'accéder aux attributs spécifiques à la classe en question (d'où l'impossibilité d'utiliser un objet ClassA).

Un objet "générique" là je t'aurais orienté vers superclasse ou interface mais qui puisse en plus te permette d'accéder aux attributs spécifiques, là ça ne doit pas être possible.

La généricité c'est bien mais ça a ses limites. Il faut bien savoir à un moment de quel type est l'objet pour pouvoir accéder à ses parties spécifiques.

[Rei Ichido]

Oui, je voudrais créer un objet du bon type et, surtout, je veux le stocker dans un objet "générique" qui accepte tous les sous-types possibles (ClassB et ClassC) mais qui me permet tout de même d'accéder aux attributs spécifiques à la classe en question (d'où l'impossibilité d'utiliser un objet ClassA).

Qu'est-ce que tu entend par "qui permet d'accéder aux attributs spécifiques" ?
S'il s'agit de dire que le traitement doit être différent en fonction du type d'objet, tu peux faire un traitement séparé (incluant l'instanciation) en fonction de la 1ère ligne. Pas très joli, mais au vu de ce que tu veux faire, j'ai du mal à voir une autre solution.

S'il ne s'agit que de classer dans différentes catégories (par exemple une classe "Chapeau" qui contiendrait une liste de A, une de B et une de C), c'est un peu le même concept : tu instancies le bon type et tu l'utilises dans une structure type switch sur enum (ou if/else, moins joli).

[Astro-Péptio]

En fait, quand je l'utilise je sais de quel type il est, mais pas quand je le stocke. Tout simplement parce que, pour le stocker, ça dépend de la première ligne de mon fichier de conf, mais quand je l'utilise dans les autres classes je sais déjà son type (qui dépend de la classe que je suis en train de faire, donc ça je peux le coder en dur).

[thelvin]

Je comprends pas, comment la programmation de toutes tes autres classes pourraient-elles dépendre de la première ligne d'un fichier de conf' ?

Les classes ont été programmées, compilées, et chargées, bien avant que ce fichier ne puisse être lu.

[Astro-Péptio]

Qu'est-ce que tu entend par "qui permet d'accéder aux attributs spécifiques" ?
S'il s'agit de dire que le traitement doit être différent en fonction du type d'objet, tu peux faire un traitement séparé (incluant l'instanciation) en fonction de la 1ère ligne. Pas très joli, mais au vu de ce que tu veux faire, j'ai du mal à voir une autre solution.

S'il ne s'agit que de classer dans différentes catégories (par exemple une classe "Chapeau" qui contiendrait une liste de A, une de B et une de C), c'est un peu le même concept : tu instancies le bon type et tu l'utilises dans une structure type switch sur enum (ou if/else, moins joli).

En fait, c'est pour créer un petit soft qui trace des plots à l'aide de JFreeChart.
J'ai créé un ensemble de classes qui contiennent les infos pour tracer les plots : les choses communes à tous les plots dans ClassA (le titre du plot et les données à mettre sur les axes X/Y entre autres), celles communes à un type de plot (données sur Z pour une surface) dans ClassB, et enfin celles spécifiques à un plot particulier (légende additionnelle, bornes...) dans ClassC.
Dans mon main, je voudrais déterminer le type de plot grâce à la première ligne du fichier de conf, m'en servir pour créer l'objet contenant ces infos (donc avec le type qui va bien), puis enregistrer cet objet dans une classe globale pour me permettre de l'utiliser dans les classes de définition de plot, par ex. Dans ces dernières, je sais quel est le type du plot donc je sais quel doit être le type de l'objet qui contient les infos de conf.
Et pour les attributs spécifiques, je veux dire que j'ai besoin de pouvoir accéder à la légende additionnelle définie dans le fichier de conf de la ClassC si je crée un plot ClassC.

[thelvin]

Il y a pas cent soixante solutions : tu stockes dans une variables de type ClasseA, et quand tu tombes sur un traitement qui "sait" que c'est un ClasseC et qui a besoin des capacités de ClasseC, tu casts en ClasseC.
En fait il ne "sait" rien du tout : il compte dessus et fera un ClassCastException sinon.

Autre possibilité : stocker, séparément, ce qui est du ClasseB et ce qui est du ClasseC.
Quand tu veux faire un traitement sur les ClasseC, tu y envoies ce que tu as stocké comme ClasseC.
Quand tu veux faire un traitement sur les ClasseB, tu y envoies ce que tu as stocké comme ClasseB... Et comme ClasseC aussi, puisqu'ils héritent de ClasseB et sont donc aussi des ClasseB.
Les génériques peuvent aider à organiser tout ça... Et peuvent ne pas. Il va que tu donnes du concret si tu veux recevoir du concret.

[Astro-Péptio]

Merci à tous pour vos réponses. J'ai finalement trouvé la solution grâce à thelvin et au remaniement de mon code : j'enregistre tout en ClassA et, dans les classes qui appellent cet objet, je sais désormais à quelle type il doit appartenir (ClassB ou ClassC par ex), ce qui me permet de caster dans le bon type.

Initialement, j'y avais pensé mais j'avais peur que cela ne fonctionne pas à cause de la "perte d'informations" lors de l'enregistrement en ClassA. En fait, les données ne sont pas perdues comme je le pensais mais seulement cachées, et sont donc toujours accessibles un fois le cast effectué.

Si ça peut aider d'autres personnes...

[NeptuS]

As-tu pensé au Design Pattern "Visitor" ??

[fallo]

Et au design pattern ?

[Astro-Péptio]

Et au design pattern ?

Maintenant oui