Complessità ciclomica di McCabe per lo switch in Java

Question

Sto utilizzando un'istruzione switch con 13 casi, ogni caso ha solo un valore di ritorno di una riga.

McCabe dipinge questo in rosso. C'è un modo più semplice per scrivere una dichiarazione di switch di grandi dimensioni? Non sembra complesso da leggere, ma non mi piace l'impostazione predefinita che diventa rossa. Se altre persone usano lo stesso strumento sul mio codice e vedono cose rosse potrebbero pensare che sono stupido :-)

Modifica: sto mappando diversi tipi di SQL per i miei più tipi astratti, quindi riducendo l'importo totale di tipi.

case Types.TIME: 
    return AbstractDataType.TIME; 
case Types.TIMESTAMP: 
    return AbstractDataType.TIME; 
case Types.DATE: 
    return AbstractDataType.TIME; 
case Types.BIGINT: 
    return AbstractDataType.NUMERIC; 
case Types.DECIMAL: 
    return AbstractDataType.NUMERIC; 

e così via ...

Answer 1

non so più di tanto sugli strumenti McCabe. Una delle cose che la complessità Cyclomatic considera sono i punti di uscita multipli.

Mi piace l'idea di EnumMap.

Se si intende utilizzare un interruttore, è possibile avere una variabile di risultato e eliminare tutte le dichiarazioni di reso. È anche possibile comprimere tutti i valori di origine che hanno lo stesso tipo di risultato:

result = null; 

case Types.TIME: 
case Types.DATE: 
case Types.TIMESTAMP: result = AbstractDataType.TIME 

// etc. 

return result; 

Penso che questo riduce la complessità ciclomatica, indipendentemente da ciò che qualcuno pensa a questo proposito come stile. Ed è un modo diverso di scrivere la dichiarazione, anche se è più facile che tu debba giudicare.

Answer 2

Si sta utilizzando il codice per esprimere ciò che realmente sono i dati. Basta usare una mappa enum o definire una volta per tutte un dizionario costante. In questo modo, stai solo parametrizzando un algoritmo di corrispondenza semplice e generico, invece di scrivere un caso di switch lungo.

Answer 3

+1 per l'idea Map ...

Qualcosa di simile a questo:

inizializzare la mappa

Map<Types, AbstractDataType> map = new HashMap<Types, AbstractDataType>(); 
map.put(Types.TIME, AbstractDataTypes.TIME); 
// and so on 

Poi nel codice semplice fai

return map.get(sqlTimeType); 

An anche la soluzione migliore sarebbe tuttavia quella di includere questa mappatura nell'enumerazione stessa in modo da poterne fare una ssuming non si ha il controllo sui tipi enum Sql ...

AbstractDataTypes.fromSqlType(timeType); 

e se lo fai:

sqlTimeType.getAbstractType(); 

Encapsulated e riutilizzabile :-)