A voir également:
- Switch & break: pour quelle logique ?
- Logiciel switch - Télécharger - Conversion & Extraction
- Prison break torrent magnet ✓ - Forum Cinéma / Télé
- Samsung switch pc - Télécharger - Divers Bureautique
- Mod minecraft switch - Forum Minecraft
- Need for speed switch 2 joueurs - Forum Jeux vidéo
3 réponses
choubaka
Messages postés
39375
Date d'inscription
jeudi 4 avril 2002
Statut
Modérateur
Dernière intervention
14 avril 2024
2 100
24 sept. 2002 à 15:22
24 sept. 2002 à 15:22
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"
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"
jisisv
Messages postés
3645
Date d'inscription
dimanche 18 mars 2001
Statut
Modérateur
Dernière intervention
15 janvier 2017
934
24 sept. 2002 à 15:43
24 sept. 2002 à 15:43
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.
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.
Utilisateur anonyme
25 sept. 2002 à 08:26
25 sept. 2002 à 08:26
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.
;-)
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.
;-)
