Garanderen dat switch-instructies volledig zijn

Het is een goede gewoonte om te garanderen dat elke switch-instructie volledig is, in die zin dat er bij elke uitvoering tijdens runtime een geschikte vertakking wordt gevonden. Als u al het volgende in aanmerking neemt, zult u inzien dat dit geen onbelangrijke taak is:

Bovendien verlangt JLS dat er op enum switch-instructies een stroomanalyse wordt toegepast. Deze kan bij het compileren onverwachte fouten aan het licht brengen:

    enum Colors { ROOD, GROEN, BLAUW }
    String colorString(Color c) {
        switch(c) {
            case ROOD: return "rood";
            case GROEN: return "groen";
            case BLAUW: return "blauw";
        }
    }

Het compileerprogramma reageert als volgt:

"Deze methode moet een resultaat van het type Tekenreeks retourneren. Let op: een probleem met betrekking tot ontbrekende 'standaard:' op 'switch' is onderdrukt; mogelijk is dit gerelateerd aan het probleem".

Dit bericht is bedoeld om gebruikers attent te maken op de verschillende betekenissen van het begrip volledigheid: de stroomanalyse die door de JLS wordt voorgeschreven, beschouwt elke enum switch-instructie zonder standaard-case als onvolledig, ook als alle (momenteel bekende) enum-constanten worden opgesomd. Het gaat hier niet alleen om RETURN-instructies, maar ook om de expliciete toewijzing van lokale variabelen of lege final-velden. Als u echter de onderstaande aanbevelingen opvolgt, treedt de bovenstaande fout nooit op.

Raadpleeg de voorkeuren van het configuratieoptie met betrekking tot de afzonderlijke configuratieopties voor het melden van diverse niveaus van onvolledigheid. Hieronder bespreken we de verschillende doelstellingen en beleidslijnen voor het ontwerp en de manier waarop deze kunnen worden gecontroleerd met behulp van het Eclipse Java-compileerprogramma.

Over het gebruik van "default:"

In het optimale geval heeft elke switch-instructie een zinvolle standaardvertakking waarmee alle gevallen worden afgehandeld die niet expliciet worden genoemd met behulp van een "always-reasonable"-strategie. Het moge duidelijk zijn dat een dergelijke strategie in veel gevallen nauwelijks of niet te vinden is, maar als u een zinvolle standaardimplementatie kunt vinden, is dat zonder meer de beste oplossing.

Aanbeveling: Door te zorgen dat het compileerprogramma u waarschuwt voor elke switch-instructie die geen standaard-case heeft, wordt u eraan herinnerd dat u voor elke switch-instructie een goede standaardimplementatie moet vinden.

Als het compileerprogramma u waarschuwt dat er een standaard-case ontbreekt, maar dat het in dit geval het beste is om standaard niets te doen, kan het ook goed zijn om dit te documenteren.

Aanbeveling: Als "niets doen" een redelijke standaardstrategie is, moet u een label default: toevoegen, waarvan de actie alleen bestaan uit commentaar waarin wordt uitgelegd dat het voor deze switch OK is om niets te doen (en waarom dat zo is). Hiermee laat u het compileerprogramma ook weten dat u niet bent vergeten om een standaard-case in te stellen.

Als u zeker weet dat er geen redelijke standaardimplementatie te vinden is, kunt u in laatste instantie voorkomen dat een onverwachte waarde de hoofdoorzaak wordt van andere fouten die verder stroomafwaarts zouden kunnen optreden. Met andere woorden: als er tijdens runtime dan tóch een fout optreedt, kan dat maar het beste zo vroeg mogelijk gebeuren.

Aanbeveling: Als er geen redelijke standaardimplementatie wordt gevonden en ook "niets doen" geen goede strategie blijkt te zijn, voegt u een case default: toe waarmee er een uitzondering wordt gegenereerd en/of een probleem wordt gelogd.

Elke switch-instructie moet kunnen worden toegewezen aan een van de bovenstaande drie categorieën. Dit betekent dat het een algemeen geldige strategie is om te zorgen dat het compileerprogramma u waarschuwt over elke ontbrekende standaard-case.

Afhandeling van alle enum-constanten

Bij het uitvoeren van een switch op een enum-waarde kan het wenselijk zijn om elke enum-constante expliciet te dekken door een bijbehorende case-instructie.

Aanbeveling: Als u gewaarschuwd wilt worden over enum switch-instructie waarin er niet voor elke enum-constante een case-instructie aanwezig is, kan het slim zijn om de optie Signaal verzenden, zelfs als standaard-case bestaat in te schakelen.

Als u niet blij bent met de optie dat alle enum-constanten moeten worden genoemd door alle enum-switches, maar u wel gewaarschuwd wilt worden over ontbrekende case-labels voor bepaalde enum switch-instructies, moet u de gewenste strategie voor elke afzonderlijke enum switch-instructie selecteren.

Aanbeveling: Als de bovenstaande waarschuwing wenselijk is voor bepaalde switch-instructies, zou u de waarschuwing overal in kunnen schalen en die switch-instructies kunnen aangeven waarvoor het acceptabel is om cases voor bepaalde enum-constanten weg te laten omdat die constanten op een geschikte manier worden gedekt door de standaard-case. Bij deze switch-instructies gebruikt u het tagcommentaar '//$CASES-OMITTED$' om een en ander te documenteren:
    String colorString2(Color c) {
        switch(c) {
        case ROOD: return "rood";
        case GROEN: return "groen";
            //$CASES-OMITTED$
        default:
        	return "kleur onbekend";
        }
    }

Tip: Als het compileerprogramma een melding geeft in de trant van "De enum-constante BLAUW moet een bijbehorend case-label nodig in deze enum-switch op Color", wordt er een snelfix aangeboden om het tagcommentaar in te voegen.

Samenvatting

De bovenstaande overwegingen laten zien dat het compileerprogramma u de meeste hulp biedt als u alle optionele waarschuwingen inschakelt met betrekking tot onvolledige switch-instructies, en dat u het beste lege gedocumenteerde standaard-cases plus het tagcommentaar //$CASES-OMITTED$ kunt gebruiken om die switch-instructies aan te geven die volgens het ontwerp niet volledig hoeven te zijn. Als u deze aanbevelingen opvolgt, krijgt u alle relevante waarschuwingen (of fouten, zo u wilt) wanneer er per ongeluk vertakkingen zijn weggelaten. Dat geldt ook voor situaties waarin één of meer enum-constanten te laat zijn toegevoegd. Alle afwijkingen van deze maximale volledigheid worden gedocumenteerd in de code en worden niet meer gemarkeerd met een waarschuwing.

Het compileerprogramma kan nog steeds niet voorkomen dat er tijdens runtime inconsistente versies van klassen worden gebruikt. Het is dus mogelijk dat er een klasse wordt gecompileerd op basis van een oude versie van een enum-type, terwijl dat enum-type in de werkende toepassing een groter aantal enum-constanten heeft. Voor deze en vergelijkbare situaties kan een passende standaardimplementatie van "catch-all" tijdens runtime uitzonderingen genereren om voor deze inconsequentie te waarschuwen. Daarmee wordt voorkomen dat de fout zich verder voortzet in de toepassing.

Een bijkomend voordeel van de strenge instellingen van het compileerprogramma die hierboven worden aanbevolen, is dat de dubieuze foutberichten over ontbrekende retourinstructies (of vergelijkbare berichten over niet-geïnitialiseerde variabelen) niet meer optreden.