Discussion :

[huzard]

Bonjour à tous,

Dans le cadre d'un projet de stage, je souhaite simplifier au maximum les opérations d'un développeur pour réaliser des opérations que je ne décrirai pas ici (je pense que celles-ci ne sont pas indispensables à connaître pour répondre à mon "problème"). Je vous explique la situation :

J'ai une classe abstraite A qui étend une classe B issue d'un framework que j'utilise, qui, dans les grosses lignes, ressemble à cela :

Code :

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

1
2
3
4
5
6
public abstract class A extends B {

< des attributs ... >
public void process() {
< fais quelque chose... >
run();
}
protected abstract void run();
}

Et l'idée est d'uniquement développer une classe C, fille de A, implémentant la méthode run()

Code :

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

1
2
3
4
5
public class C extends A {

 < d'autres attributs, à la guise du codeur... >
@Override
protected void run() {
< fais quelque chose... >
}
}

Ce bout de code illustre mon besoin : minimiser l'effort d'un autre développeur et centraliser les calculs dans la classe mère. Bon, quoiqu'il en soit, il marche exactement comme je veux, mais est-ce la bonne façon de procéder ? Je veux dire, cette façon de faire est elle admise comme correcte (je le fais souvent quand je code en fait, que ce soit en Java ou C++ ou tout autre langage objet), ou alors vaut il mieux créer une interface avec une méthode run() et composer la classe A d'une implémentation de cette interface ? En gros, ma question s'oriente davantage sur une propreté de conception.


Si je n'ai pas été très clair dans la description de mon soucis, n'hésitez pas à me le dire.

Merci pour vos futurs réponses.

[junior222]

Si je n'ai pas été très clair dans la description de mon soucis, n'hésitez pas à me le dire.

Merci pour vos futurs réponses.

Oui je confirme tu n'as pas été assez clair pour moi

[thelvin]

Composition ou spécialisation, les deux sont très bien en général, et parfaitement admis.
Lequel est le mieux en particulier, tout dépend de tout ce que tu ne nous as pas montré.

Personnellement, je dirais qu'il vaut mieux viser la composition, ou juste passer l'objet Runnable en paramètre, sauf quand l'architecture du code rend autre chose plus pragmatique ou plus maintenable.

[tchize_]

Une question de base à te poser, c'et de savoir si la class C aura besoin des méthodes et paramètres présents dans A pour fonctionner. Ou au contraire, est-ce que toutes les méthodes présentes dans A ne sont que des méthodes qui concernent un autre bout de code qui utilise A (comme par exemple des règles de scheduling, du stockage d'erreurs, etc). Dans le premier cas, une interface n'est pas pratique, puisque alors, C ne connaitrait pas l'instance de A qui lui correspond. Dans le second, l'interface serait probablement préférable car donnant plus de liberté à celui qui implémente C.

[huzard]

En effet la classe C vise juste à spécialiser les calculs de A, donc elle se doit de connaître certaines particularités de A, etnotamment d'y ajouter des informations dans une hashmap. Merci pour vos réponses :-)