Avoir une chaîne d'opérations "instanceof" est considéré comme une "odeur de code". La réponse standard est "utiliser le polymorphisme". Comment le ferais-je dans ce cas?
Il existe un certain nombre de sous-classes d'une classe de base; aucun d'entre eux n'est sous mon contrôle. Une situation analogue serait avec les classes Java Integer, Double, BigDecimal etc.
if (obj instanceof Integer) {NumberStuff.handle((Integer)obj);}
else if (obj instanceof BigDecimal) {BigDecimalStuff.handle((BigDecimal)obj);}
else if (obj instanceof Double) {DoubleStuff.handle((Double)obj);}
J'ai le contrôle sur NumberStuff et ainsi de suite.
Je ne veux pas utiliser beaucoup de lignes de code là où quelques lignes feraient l'affaire. (Parfois, je fais un HashMap mappant Integer.class à une instance de IntegerStuff, BigDecimal.class à une instance de BigDecimalStuff etc. Mais aujourd'hui, je veux quelque chose de plus simple.)
J'aimerais quelque chose d'aussi simple que ceci:
public static handle(Integer num) { ... }
public static handle(BigDecimal num) { ... }
Mais Java ne fonctionne tout simplement pas de cette façon.
Je voudrais utiliser des méthodes statiques lors du formatage. Les choses que je formate sont composites, où un Thing1 peut contenir un tableau Thing2s et un Thing2 peut contenir un tableau de Thing1s. J'ai eu un problème lorsque j'ai implémenté mes formateurs comme ceci:
class Thing1Formatter {
private static Thing2Formatter thing2Formatter = new Thing2Formatter();
public format(Thing thing) {
thing2Formatter.format(thing.innerThing2);
}
}
class Thing2Formatter {
private static Thing1Formatter thing1Formatter = new Thing1Formatter();
public format(Thing2 thing) {
thing1Formatter.format(thing.innerThing1);
}
}
Oui, je connais le HashMap et un peu plus de code peut aussi résoudre ce problème. Mais l '"instanceof" semble si lisible et maintenable par comparaison. Y a-t-il quelque chose de simple mais pas malodorant?
Note ajoutée le 5/10/2010:
Il s'avère que de nouvelles sous-classes seront probablement ajoutées à l'avenir, et mon code existant devra les gérer avec élégance. Le HashMap sur la classe ne fonctionnera pas dans ce cas car la classe ne sera pas trouvée. Une chaîne d'instructions if, commençant par la plus spécifique et se terminant par la plus générale, est probablement la meilleure après tout:
if (obj instanceof SubClass1) {
// Handle all the methods and properties of SubClass1
} else if (obj instanceof SubClass2) {
// Handle all the methods and properties of SubClass2
} else if (obj instanceof Interface3) {
// Unknown class but it implements Interface3
// so handle those methods and properties
} else if (obj instanceof Interface4) {
// likewise. May want to also handle case of
// object that implements both interfaces.
} else {
// New (unknown) subclass; do what I can with the base class
}
[text](link)
pour publier des liens dans les commentaires.