Pourquoi avons-nous besoin de pause après l'affaire états?

Il est parfois utile d'avoir plusieurs cas associé avec le même bloc de code, tels que

case 'A':
case 'B':
case 'C':
    doSomething();
    break;

case 'D':
case 'E':
    doSomethingElse();
    break;

etc. Juste un exemple.

Dans mon expérience, il est généralement mauvais style de "tomber" et ont plusieurs blocs de code à exécuter pour un cas, mais il peut être utilise dans certaines situations.

Java vient de C et qui est de la syntaxe de C.

Il y a des moments où vous souhaitez que plusieurs cas de déclarations pour avoir un chemin d'exécution.
Ci-dessous est un exemple qui va vous dire combien de jours dans un mois.

class SwitchDemo2 {
    public static void main(String[] args) {

        int month = 2;
        int year = 2000;
        int numDays = 0;

        switch (month) {
            case 1:
            case 3:
            case 5:
            case 7:
            case 8:
            case 10:
            case 12:
                numDays = 31;
                break;
            case 4:
            case 6:
            case 9:
            case 11:
                numDays = 30;
                break;
            case 2:
                if ( ((year % 4 == 0) && !(year % 100 == 0))
                     || (year % 400 == 0) )
                    numDays = 29;
                else
                    numDays = 28;
                break;
            default:
                System.out.println("Invalid month.");
                break;
        }
        System.out.println("Number of Days = " + numDays);
    }
}

Vous pouvez faire toutes sortes de choses intéressantes avec cas de chute à travers.

Par exemple, disons que vous voulez faire une action particulière pour tous les cas, mais dans certains cas, vous voulez faire une action plus quelque chose d'autre. À l'aide d'une instruction switch avec fall-through serait assez facile.

switch (someValue)
{
    case extendedActionValue:
        //do extended action here, falls through to normal action
    case normalActionValue:
    case otherNormalActionValue:
        //do normal action here
        break;
}

Bien sûr, il est facile d'oublier le break déclaration à la fin d'un cas et de provoquer un comportement inattendu. Bon compilateurs vous avertira si vous omettez l'instruction break.

De sorte que vous ne pas avoir à répéter le code si vous avez besoin de plusieurs cas de faire la même chose:

case THIS:
case THAT:
{
    code;
    break;
}

Ou vous pouvez faire des choses comme :

case THIS:
{
   do this;
}
case THAT:
{
   do that;
}

Dans une cascade de mode.

Vraiment un bug/confusion sur le ventre, si vous me demandez.

Autant que le record historique de passe, Tony Hoare a inventé le cas dans les années 1960, lors de la "programmation structurée" de la révolution. Tony le cas de déclaration de multiples étiquettes par cas et sortie automatique sans puant break consolidés. L'exigence expresse de la break était quelque chose qui venait du BCPL/B/C ligne. Dennis Ritchie écrit (ACM HOPL-II):

Par exemple, la endcase qui s'échappe d'un BCPL switchon déclaration n'était pas présent dans la langue
lorsque nous avons appris au cours des années 1960, et donc la surcharge de la pause de mot-clé pour échapper à
du B et C de l'instruction switch doit à la divergence d'évolution plutôt que conscient du changement.

Je n'ai pas été en mesure de trouver toute les écrits historiques sur BCPL, mais Ritchie commentaire suggère que la break était plus ou moins un accident historique. BCPL plus tard, a résolu le problème, mais peut-être Ritchie et Thompson étaient trop occupés à inventer Unix à être dérangé par tel détail 🙂

Que les gens ont dit avant, c'est de permettre à l'automne et il n'est pas une erreur, c'est une fonctionnalité.
Si un trop grand nombre break déclarations de vous ennuyer, vous pouvez facilement se débarrasser d'eux en utilisant return plutôt les instructions. C'est effectivement une bonne pratique, parce que vos méthodes doit être aussi petite que possible (pour des raisons de lisibilité et maintenabilité), donc un switch déclaration est déjà assez grand pour une méthode, par conséquent, une bonne méthode ne doit pas contenir autre chose, c'est un exemple:

public class SwitchTester{
    private static final Log log = LogFactory.getLog(SwitchTester.class);
    public static void main(String[] args){
        log.info(monthsOfTheSeason(Season.WINTER));
        log.info(monthsOfTheSeason(Season.SPRING));
        log.info(monthsOfTheSeason(Season.SUMMER));
        log.info(monthsOfTheSeason(Season.AUTUMN));
    }

    enum Season{WINTER, SPRING, SUMMER, AUTUMN};

    static String monthsOfTheSeason(Season season){
        switch(season){
            case WINTER:
                return "Dec, Jan, Feb";
            case SPRING:
                return "Mar, Apr, May";
            case SUMMER:
                return "Jun, Jul, Aug";
            case AUTUMN:
                return "Sep, Oct, Nov";
            default:
                //actually a NullPointerException will be thrown before reaching this
                throw new IllegalArgumentException("Season must not be null");
        }        
    }
}   

L'exécution des tirages:

12:37:25.760 [main] INFO lang.SwitchTester - Dec, Jan, Feb
12:37:25.762 [main] INFO lang.SwitchTester - Mar, Apr, May
12:37:25.762 [main] INFO lang.SwitchTester - Jun, Jul, Aug
12:37:25.762 [main] INFO lang.SwitchTester - Sep, Oct, Nov

comme prévu.

parce qu'il y a des situations où vous voulez à circuler à travers le premier bloc pour éviter par exemple d'écrire le même code en plusieurs blocs, mais encore être en mesure de les répartir de manière plus de contrôle. Il y a aussi une tonne d'autres raisons.

Vous pouvez les rend facilement repérables autre type de nombre, le mois, le comte.

C'est mieux alors si dans ce cas;

public static void spanishNumbers(String span){

    span = span.toLowerCase().replace(" ", "");
    switch (span){
     case "1":    
     case "jan":  System.out.println("uno"); break;    
     case "2":      
     case "feb":  System.out.println("dos"); break;    
     case "3":     
     case "mar":  System.out.println("tres"); break;   
     case "4":   
     case "apr":  System.out.println("cuatro"); break;
     case "5":    
     case "may":  System.out.println("cinco"); break;
     case "6":     
     case "jun":  System.out.println("seis"); break;
     case "7":    
     case "jul":  System.out.println("seite"); break;
     case "8":    
     case "aug":  System.out.println("ocho"); break;
     case "9":   
     case "sep":  System.out.println("nueve"); break;
     case "10":    
     case "oct": System.out.println("diez"); break;
     }
 }

Exactement, car avec certains placement intelligent, vous pouvez exécuter les blocs en cascade.