Switch & break: pour quelle logique ?

Fermé
-
Messages postés
618
Date d'inscription
vendredi 26 juillet 2002
Statut
Membre
Dernière intervention
13 juillet 2013
-
Dans les nouveaux langages tels que Java, PHP, JavaScript, ..., on est obligé de placer des Break pour sortir des blocs d'instructions invoqués par Switch (ou Caseof ou autre...), sans quoi les blocs suivants sont exécutés (argh !).
Quelqu'un peut-il me dire pourquoi les concepteurs de ces langages ont-ils cru bon de d'implémenter ainsi ces structures conditionnelles, à contre-pieds des anciens langages ? Peut-on me donner un exemple de programmation où les Break ne sont pas utilisés dans un Switch ?

3 réponses

Messages postés
38795
Date d'inscription
jeudi 4 avril 2002
Statut
Modérateur
Dernière intervention
27 janvier 2022
2 043
salut

il me semble que lorsque tu utilise le switch en java avec un "return" le break n'est pas nécessaire

Chouba
"Obsédé des travaux manuels non pratiquant"
Messages postés
3645
Date d'inscription
dimanche 18 mars 2001
Statut
Modérateur
Dernière intervention
15 janvier 2017
965
Ceci permets de regrouper plusieurs case

case 1:
case 3:
tagada();
break;
case 2:
brol();
break;



Le C connait un break depuis l'origine et ce n'est pas un langage de dernière jeunesse non?
The software said "Requires Windows98, Win2000, or better
So I installed Unix.
Messages postés
618
Date d'inscription
vendredi 26 juillet 2002
Statut
Membre
Dernière intervention
13 juillet 2013
971
Exemple:

public void validChoice(int choice){
switch(choice){
case 1:
initialize();
doSomething();
case 2:
doSomethingElse();
case 3:
doOtherAction();
break;
case 4:
doCase4and5Action();
case 5:
doOnlyCase5Action();
break;
default:
doSomething();
}
}

Dans cet exemple, suivant le choix effectué, méthode 'doSomethingElse()' est appelée dans le cas '1' et '2'
mais dans le cas '1', la méthode 'initialize()' est appelée auparavant.

La méthode 'doSomething()' n'est quant à elle appelée que pour les cas '1' et pour tous les autres cas que '2', '3', '4', '5'.
Cela peut être utile si différents comportement sont possibles en fonction d'une valeur.

MAIS il faut à tout prix éviter l'emploi de la commande 'switch' qui rend le code moins (pas) portable.

Comment faire alors?
En utilisant le polymorphisme, avantage de l'Orienté-Objet.

Et en pratique?
Crée une interface (appelons-la 'ChoiceInterface') qui contient une (ou des) méthode(s).
Crée une classe par choix possible qui implémente ChoiceInterface.

Quel que soit le choix effectué (dans l'exemple), tu appelles la méthode voulue de l'interface et c'est l'implémentation de cette méthode dans la classe correspondante qui sera exécutée.

Exemple:
-----------

public interface ChoiceInterface{
public Object handleChoice();
}

public interface DoSomething extends ChoiceInterface{
public void doSomething();
}

public interface DoSomethingElse extends ChoiceInterface{
public void doSomethingElse();
}

public interface DoOtherAction extends ChoiceInterface{
public void doOtherAction();
}

public interface DoAction4and5Action extends ChoiceInterface{
public void doOtherAction();
}

public interface DoOnlyCase5 extends ChoiceInterface{
public void doOtherAction();
}


public class Choice_1 implements DoSomething, DoSomethingElse, DoOtherAction{
public Object handleChoice(){
doSomething();
doSomethingElse();
doOtherAction();
}

public void doSomething(){
//some code
}

public void doSomethingElse(){
//some other code
}

public void doOtherAction(){
//more other code
}
}
}


public class Choice_2 implements DoSomething, DoSomethingElse{
public Object handleChoice(){
doSomethingElse();
doOtherAction();
}

public void doSomethingElse(){
//some other code
}


public void doOtherAction(){
//more code
}
}
}

etc..

.
.
.
//Exemple d'utilisation
ArrayList choices = new ArrayList();
choices.add(new Choice_1());
choices.add(new Choice_2());
choices.add(new Choice_4());
choices.add(new Choice_1());
choices.add(new Choice_3());
Iterator it = choices.iterator();
while(it.hasNext()){
ChoiceInterface aChoice = (ChoiceInterface)it.next();
aChoice.handleChoice();
}


Ces deux codes donnent le même résultats, mais celui utilisant les interfaces est plus propre et plus facile à maintenir.

;-)