Comment éviter les déclarations switch-case En Java [dupliquer]
Cette question a déjà une réponse ici:
- Conversion d'un grand nombre de "if else' déclarations à l'assainissement de l'approche 7 réponses
j'ai un enum de Trigertype, où différents triggers peuvent être ajoutés
public enum TriggerType {
meta,data,list,toggle
}
ces types de déclencheurs sont utilisés à l'intérieur de différents manipulateurs (par ex. composant, tableau de bord, etc.) pour identifier la gâchette est déclenchée à l'intérieur du handler par un switch-case, Pour par exemple Code snippet de ComponentHandler en utilisant la trigger through switch-case est donnée ci-dessous
@Override
public TriggerResultInterface executeTriggerJob(TriggerEventHelper triggerEventHelper) throws TriggerHandlerException {
switch (triggerEventHelper.getTriggerName()) {
case meta:
return getMetaComponentConfig(triggerEventHelper);
case data:
return getComponentData(triggerEventHelper);
default:
LOGGER.debug(INVALID_TRIGGER_NAME_CONFIGURED);
throw new TriggerHandlerException(INVALID_TRIGGER_NAME_CONFIGURED);
}
}
imaginez si je veux ajouter un nouveau déclencheur, je dois mettre à jour la classe enum qui est inévitable, en même temps je dois mettre à jour chacune de mes classes handler qui ce déclencheur doit être utilisé, est-ce que cette façon de conception avec le codage est bonne ou est-il tout-autre meilleure solution qui permettra d'améliorer ce code et suit solide principes avec une meilleure conception.
<!-Je tiens à souligner que cette question n'est pas une copie de . Il n'y a qu'un seul comportement nécessaire dans cette situation pour chaque type (par exemple: convertToMp3). Mais ce à quoi ma question se réfère est mon type enum (Trigger Type) dépend des gestionnaires qu'il pourrait éventuellement être utilisé, de sorte que le comportement ou l'implémentation de chaque type de Trigger enum dépendra de l'exigence du gestionnaire qu'il est utilisé.1 réponses
une des solutions consiste à utiliser le polymorphisme pour traiter les déclencheurs différemment. Par exemple, vous pouvez déclarer le Trigger et ont plusieurs implémentations. Dans ce cas, lorsque vous avez besoin d'un nouveau type de trigger, vous n'avez qu'à implémenter cette interface et ne touchez pas le code existant:
public interface Trigger {
TriggerResultInterface execute(TriggerEventHelper eventHelper);
}
public class MetaTrigger implements Trigger {
@Override
TriggerResultInterface execute(TriggerEventHelper eventHelper) {
// do meta trigger work here
}
}
public class DataTrigger implements Trigger {
@Override
TriggerResultInterface execute(TriggerEventHelper eventHelper) {
// do data trigger work here
}
}
// ...
public TriggerResultInterface executeTriggerJob(TriggerEventHelper eventHelper) {
eventHelper.getTrigger().execute(eventHelper);
}
dans ce cas, il sera impossible d'ajouter un nouveau type de déclencheur et de ne pas implémenter son comportement.
si vous avez besoin d'une implémentation par défaut, vous pouvez utiliser une classe de base à la place de l'interface (dans Java 8, vous pouvez ajouter une implémentation par défaut dans l'interface).