cosa significa Codice Morto in Eclipse IDE Problemi Sezione

Question

Sto usando Eclipse Helios IDE per lo sviluppo di applicazioni Web. Nella sezione Problemi in Eclipse, per alcune linee la descrizione viene visualizzata come "Codice Morto".

Qualcuno potrebbe dirmi che cosa Dead Code in realtà significa?

prega di consultare la schermata per il vostro riferimento.

Ad esempio questa parte è mostrato come codice morto sotto Eclipse

else { 
     int length; 
     if (ar != null) 
      length = Array.getLength(ar); 
     else 
      length = 0; // This line is dead code 

Answer 1

In Eclipse, "codice morto" è un codice che non sarà mai eseguito. Di solito è in un ramo condizionale che logicamente non verrà mai inserito.

Un esempio banale potrebbe essere il seguente:

boolean x = true; 
if (x) { 
    // do something 
} else { 
    // this is dead code! 
} 

Non è un errore, perché è ancora java valida, ma è un avvertimento utile, soprattutto se le condizioni logiche sono complessi, e dove non può essere intuitivamente ovvio che il codice sarà mai essere eseguito.

Nel proprio esempio specifico, Eclipse ha calcolato che ar sarà sempre non nullo e pertanto il ramo else length = 0 non verrà mai eseguito.

E sì, è possibile che Eclipse è sbagliato, ma è molto più probabile che non lo sia.

Answer 2

Dead Code è un codice che non sarà mai eseguita, ad esempio,

boolean b = true 
if (!b) { 
    .... 
    // dead code here 
} 

Answer 3

Codice guasto significa che non è possibile che questo codice venga eseguito.

A volte addirittura non può compilarlo (come questo caso :)

private Boolean dead_code() 
    { 
    return true; 
    //Dead code below: 
    dosomething(); 
    } 

Ma in altri casi questo non è troppo evidente, ad esempio, questa dichiarazione:

b=true; 
    [...] 
    if (b==false) 
    { 
    //Dead code 
    } 

Se avete questo messaggio, ci è qualche grave difetto nel codice. Devi trovarlo, altrimenti la tua app non funzionerà come previsto.

Answer 4

Esistono due tipi di diagnostica che Eclipse emette per il codice di marcatura che sarà/non può essere eseguito in fase di esecuzione. 1) Codice irraggiungibile: questi sono i soliti avvisi java che seguono le regole di irraggiungibilità del JLS e sono forniti anche da javac. Questi sono pensati per essere errori di compilazione. Esempi:

int foo() { 
     return 1; 
     int i = 1; // Unreachable 
    } 
    int foo2() { 
    while (true); 
    int i =1; //Unreachable 
    } 

Ci sono altri esempi più complicati :)

2) Dead Code: Questo è proprio avvertimenti analisi statica di Eclipse, e sono per lo più legati dalla analisi nullo cioè

void foo() { 
    Object o = null; 
    if (o == null) { 
    } else { 
    // dead code 
    } 

Gli esempi sopra riportati NON devono fornire un avviso di codice guasto. vale a dire

boolean x = true; 
if (x) { 
    // do something 
} else { 
    // this is dead code! 
} 

non dovrebbe dare l'avvertimento, perché JLS vieta il compilatore per valutare il 'valore' di variabili. Tutto ciò che possiamo valutare è la 'nullness'

Spero che questo aiuti

Answer 5

Si potrebbe essere avere un Eccezione puntatore nullo nelle righe sopra le righe "codice morto". Assicurati di verificare l'eccezione "Puntatore nullo".

Answer 6

Prova questa:

while (true) { 
    if(false == true) break; 

} 

S.O.P("I will never reach here!") <-- This code will never be executed. 

Il codice è valido in quanto conforme al compilatore, ma in realtà non potrà mai uscire, e in effetti non verrà mai eseguito il ciclo S.O.P.

Answer 7

È possibile che sia stata utilizzata la variabile ar in precedenza. Quindi il compilatore sa che la riga nell'istruzione else non verrà mai eseguita. O ci sarà un NullPointerException nel luogo in cui è stato utilizzato ar o verrà eseguita la prima parte dell'istruzione if.

Answer 8

lasciami dare qualche risposta per il codice guasto.

Esempio:

public class UnreachableTest{ 

    public static void main(){ 

     try{ 
      // some code 
     } 
     catch(Exception exc){ 
      throw new NullPointerException(); 
      System.out.println("Unreachable line"); // compile time error 
     } 
    } 

} 

qui lo System.out.println ("linea irraggiungibile"); non viene mai eseguito. Che a sua volta considerato un codice morto.

Un altro esempio può essere:

int func(int i, int j) 
{ 
int sum = i + j; 
return i + j; // never actually using the sum 
} 

semplici restituisce la funzione i + j; mai veramente usa la somma. Sum è considerato come codice morto qui.

Answer 9

In altri casi, quando ciò accade.

System.out.println("result :" + result + ":" + result.isEmpty()); 
if (result == null) 
    return result; 
else if(!result.isEmpty()) 
    str.append(result + " "); 

1) Qui, come si si stampa risultato e controllo isEmpty() Eclipse presuppone che risultato non è nullo in modo da non andare in se. Quindi il risultato di ritorno è un codice morto.

2) Ora diciamo risultato è in arrivo nullo in modo da otterrete NullPointerException in result.isEmpty() in modo ancora una volta non andrà in se e risultato ritorno è deadcode

Per fare questo lavoro solo come commento sistema. out.println().

Answer 10

Eclipse emette questo avviso se il controllo condizione che si sta dando potrebbe non essere mai soddisfatto.Di seguito sono riportati alcuni esempi

Object o=null; 
if(o!=null) { 
//Some code 

} 

avvisi codice qui Morto verrà come oggetto già effettuate nullo

Un altro esempio è il seguente

BSTTest bstTest=null; 
bstTest.test=10; 
if(bstTest==null) { 
    //some code 

} 

Qui il codice tenta di accedere a una variabile del classe. Dato che la variabile è già stata acceduta, eclipse fornirà un avviso di codice inattivo in if (bstTest == null) poiché bstTest potrebbe non essere nullo quando la variabile è già in accesso.

Nota: Qui bstTest.test darà un'eccezione di puntatore nullo