Qual è SuppressWarnings ( “incontrollato”) in Java?

StackOverflow https://stackoverflow.com/questions/1129795

Domanda

A volte quando si guarda attraverso il codice, vedo molti metodi specificano un'annotazione: 

@SuppressWarnings("unchecked")

Che cosa significa questo?

È stato utile?

Soluzione

A volte generici Java semplicemente non consentono di fare ciò che si vuole, e avete bisogno di raccontare in modo efficace al compilatore che quello che stai facendo davvero essere legale in fase di esecuzione.

Di solito trovo questo un dolore quando sto beffardo un'interfaccia generica, ma ci sono altri esempi anche. Di solito è la pena cercando di capire un modo per evitare l'avvertimento, piuttosto che sopprimere (il Java Generics FAQ aiuta qui), ma a volte anche se è è possibile, si piega il codice fuori forma tanto che sopprimere l'avviso è più ordinato. Aggiungere sempre un commento esplicativo in questo caso!

Lo stesso farmaci generici FAQ ha diverse sezioni su questo tema, a partire da "Che cosa è un avvertimento "incontrollato" " -?. vale la pena una lettura

Altri suggerimenti

Si tratta di un'annotazione di sopprimere la compilazione avvertimenti circa le operazioni incontrollate generiche (non eccezioni), come calchi. Essa implica in sostanza che il programmatore non ha voluto essere avvisati su questi che si è già a conoscenza di quando la compilazione di una particolare porzione di codice.

Si può leggere di più su questo specifica annotazione qui:

  

SuppressWarnings

Inoltre, Oracle fornisce una certa documentazione tutorial su l'uso di annotazioni qui:

  

NOTE

come dicono loro,

  

"L'avvertimento 'incontrollata' può verificarsi quando ci si interfaccia con il codice legacy scritto prima dell'avvento dei farmaci generici (discussi nella lezione intitolata Generics)".

Si potrebbe anche significare che l'attuale versione del sistema di tipo Java non è abbastanza buono per il vostro caso. Ci sono stati diversi proposizioni JSR / hack per risolvere questo: token tipo, Tipo Super Gettoni , Class.cast ().

Se si ha realmente bisogno di questa soppressione, restringere il più possibile (ad esempio, non inserirlo sulla classe stessa o su un lungo metodo). Un esempio: 

public List<String> getALegacyListReversed() {
   @SuppressWarnings("unchecked") List<String> list =
       (List<String>)legacyLibrary.getStringList();

   Collections.reverse(list);
   return list;
}

Il SuppressWarning annotazione è usato per sopprimere gli avvertimenti del compilatore per l'elemento annotato. In particolare, la categoria unchecked consente la soppressione di avvisi del compilatore generato come risultato di tipo incontrollato getta.

Semplicemente:. E 'un avvertimento con cui il compilatore indica che esso non può garantire la sicurezza di tipo

metodo di servizio APP per esempio: 

@SuppressWarnings("unchecked")
public List<User> findAllUsers(){
    Query query = entitymanager.createQuery("SELECT u FROM User u");
    return (List<User>)query.getResultList();
}

Se io didn'n anotate le @SuppressWarnings ( "incontrollato") qui, sarebbe un problema con la linea, dove voglio restituire il mio risultante.

In scorciatoia tipo di sicurezza significa:. Un programma viene considerato type-safe se si compila senza errori e gli avvisi e non solleva alcun inaspettato ClassCastException s in fase di esecuzione

I costruire su http://www.angelikalanger.com/GenericsFAQ/FAQSections/Fundamentals .html

In Java, i generici sono implementate per mezzo di tipo cancellazione. Per esempio, il codice seguente. 

List<String> hello = List.of("a", "b");
String example = hello.get(0);

è redatto al seguito. 

List hello = List.of("a", "b");
String example = (String) hello.get(0);

E List.of è definito come. 

static <E> List<E> of(E e1, E e2);

Che dopo la cancellazione di tipo diventa. 

static List of(Object e1, Object e2);

Il compilatore non ha idea di che cosa sono i tipi generici in fase di runtime, quindi se si scrive qualcosa di simile. 

Object list = List.of("a", "b");
List<Integer> actualList = (List<Integer>) list;

Java Virtual Machine non ha idea di quali tipi generici sono durante l'esecuzione di un programma, quindi questo viene compilato ed eseguito, per quanto riguarda Java Virtual Machine, questo è un cast di List tipo (questa è l'unica cosa che si può verificare, in modo da verificare solo quello).

Ma ora aggiungere questa linea. 

Integer hello = actualList.get(0);

E JVM genera un ClassCastException inaspettato, come compilatore Java inserito un cast implicito. 

java.lang.ClassCastException: java.base/java.lang.String cannot be cast to java.base/java.lang.Integer

Un avvertimento unchecked dice un programmatore che un cast può causare un programma per generare un'eccezione da qualche altra parte. Sopprimere l'avviso con @SuppressWarnings("unchecked") dice al compilatore che il programmatore ritiene che il codice per essere sicuro e non causerà eccezioni impreviste.

Perché vorresti farlo? sistema di tipo Java non è sufficiente per rappresentare tutti i possibili modelli di utilizzo tipo. A volte si può sapere che un cast è sicuro, ma Java non fornisce un modo per dire così - per nascondere le avvertenze come questo, @SupressWarnings("unchecked") può essere utilizzato, in modo che un programmatore può concentrarsi sulle avvertenze reali. Ad esempio, Optional.empty() restituisce un singleton di evitare un'assegnazione di opzionali vuote che non memorizzare un valore. 

private static final Optional<?> EMPTY = new Optional<>();
public static<T> Optional<T> empty() {
    @SuppressWarnings("unchecked")
    Optional<T> t = (Optional<T>) EMPTY;
    return t;
}

Questo cast è sicuro, in quanto il valore memorizzato in un optional vuoto non può essere recuperata in modo non v'è alcun rischio di inaspettate eccezioni di classe del cast.

È possibile eliminare gli avvertimenti del compilatore e dire ai farmaci generici che il codice che avevate scritto è legale in base ad esso.

Esempio: 

@SuppressWarnings("unchecked")
public List<ReservationMealPlan> retreiveMealPlan() {
     List<ReservationMealPlan> list=new ArrayList<ReservationMealPlan>();
    TestMenuService testMenuService=new TestMenuService(em, this.selectedInstance);
    list = testMenuService.getMeal(reservationMealPlan);
    return list;
 }

Un trucco è quello di creare un'interfaccia che si estende un'interfaccia di base generico ... 

public interface LoadFutures extends Map<UUID, Future<LoadResult>> {}

Quindi è possibile controllare con instanceof prima che il cast ... 

Object obj = context.getAttribute(FUTURES);
if (!(obj instanceof LoadFutures)) {
    String format = "Servlet context attribute \"%s\" is not of type "
            + "LoadFutures. Its type is %s.";
    String msg = String.format(format, FUTURES, obj.getClass());
    throw new RuntimeException(msg);
}
return (LoadFutures) obj;

Per quanto so, per ora ha a che fare con la soppressione avvertimenti su farmaci generici; farmaci generici sono un nuovo costrutto di programmazione non è supportato nelle versioni JDK precedenti di JDK 5, in modo che qualsiasi mix di vecchi costrutti con quelli nuovi potrebbero comportare alcuni risultati imprevisti.

Il compilatore avvisa il programmatore a questo proposito, ma se il programmatore sa già, si può trasformare questi avvertimenti temute fuori usando SuppressWarnings.

Un avviso con cui il compilatore indica che esso non può garantire la sicurezza di tipo. Il termine di avvertimento "incontrollato" è fuorviante. Ciò non significa che l'avvertimento non è selezionata in alcun modo. Il termine "incontrollato" si riferisce al fatto che il compilatore e il sistema runtime non dispongono di informazioni di tipo sufficiente per eseguire tutti i tipi controlli che sarebbero necessari per garantire la sicurezza di tipo. In questo senso, alcune operazioni sono "incontrollato".

La fonte più comune di avvertimenti "incontrollato" è l'uso di tipi prime. avvertimenti "non controllate" sono emesse quando un oggetto si accede tramite una variabile di tipo grezzo, perché il tipo grezzo non fornisce informazioni sul tipo sufficiente per eseguire tutti i controlli di tipo necessari.

Esempio (di avvertimento incontrollato in combinazione con i tipi di prime): 

TreeSet set = new TreeSet(); 
set.add("abc");        // unchecked warning 
set.remove("abc");

warning: [unchecked] unchecked call to add(E) as a member of the raw type java.util.TreeSet 
               set.add("abc");  
                      ^

Quando il metodo Add viene richiamato il compilatore non sa se è sicuro di aggiungere un oggetto String alla raccolta. Se il TreeSet è una raccolta che contiene String s (o un supertipo di esso), allora sarebbe al sicuro. Ma dalle informazioni di tipo fornite dal tipo grezzo TreeSet il compilatore non può dire. Da qui la chiamata è potenzialmente pericoloso e un avvertimento "incontrollato" viene emessa.

avvertimenti "non controllate" sono riportati anche quando il compilatore trova un getto il cui tipo di destinazione o è un tipo parametrico o di un parametro di tipo.

Esempio (di un avviso non controllato in combinazione con un getto di un tipo parametrico o digitare variabile): 

  class Wrapper<T> { 
  private T wrapped ; 
  public Wrapper (T arg) {wrapped = arg;} 
  ... 
  public Wrapper <T> clone() { 
    Wrapper<T> clon = null; 
     try {  
       clon = (Wrapper<T>) super.clone(); // unchecked warning 
     } catch (CloneNotSupportedException e) {  
       throw new InternalError();  
     } 
     try {  
       Class<?> clzz = this.wrapped.getClass(); 
       Method   meth = clzz.getMethod("clone", new Class[0]); 
       Object   dupl = meth.invoke(this.wrapped, new Object[0]); 
       clon.wrapped = (T) dupl; // unchecked warning 
     } catch (Exception e) {} 
     return clon; 
  } 
} 

warning: [unchecked] unchecked cast 
found   : java.lang.Object 
required: Wrapper <T> 
                  clon = ( Wrapper <T>)super.clone();  
                                                ^ 
warning: [unchecked] unchecked cast 
found   : java.lang.Object 
required: T 
                  clon. wrapped = (T)dupl;

Un cast il cui tipo di destinazione o è un (jolly cemento o limitato) tipo parametrico o un parametro di tipo non è sicuro, se è coinvolto un tipo di controllo dinamico in fase di esecuzione. Al runtime, solo il tipo di cancellazione è disponibile, non il tipo statico esatto che è visibile nel codice sorgente. Di conseguenza, la parte di esecuzione del getto viene eseguito in base al tipo di cancellazione, non del tipo statico esatto.

Nell'esempio, il cast Wrapper sarebbe verificare se l'oggetto restituito dal super.clone è un involucro, non si tratti di un involucro con un particolare tipo di membri. Analogamente, i calchi al parametro di tipo T sono espressi al tipo di oggetto in fase di esecuzione, e probabilmente ottimizzati via del tutto. A causa di cancellazione del tipo, il sistema runtime è in grado di effettuare controlli di tipo più utili in fase di esecuzione.

In un modo, il codice sorgente è fuorviante, perché suggerisce che viene eseguito un cast al rispettivo tipo di destinazione, mentre in realtà la parte dinamica del cast controlla solo contro la cancellazione del tipo del tipo di destinazione. L'avvertimento "incontrollato" viene rilasciato per attirare l'attenzione del programmatore a questa mancata corrispondenza tra l'aspetto statico e dinamico del cast.

Si prega di fare riferimento: Che cosa è un avvertimento "incontrollato"?

@SuppressWarnings annotazione è uno dei tre annotazioni incorporate disponibili in JDK e ha aggiunto al fianco di @Override e @deprecated in Java 1.5.

@SuppressWarnings istruiscono il compilatore di ignorare o sopprimere, warning del compilatore specificato elemento annotato e tutti gli elementi del programma all'interno di tale elemento. Ad esempio, se una classe è indicata a trattenere un particolare avviso, quindi un avvertimento generato in un metodo interno che classe sarà anche essere separata.

@SuppressWarnings

Potreste aver visto ( "incontrollato") e @SuppressWarnings ( "seriali"), due degli esempi più popolari di @SuppressWarnings annotazione. Primo è utilizzato per sopprimere avvertimento generato a causa di fusione incontrollata, mentre l'avviso in seguito viene utilizzato per ricordare di aggiungere serialVersionUID in una classe serializzabile.

Per saperne di più: https://javarevisited.blogspot.com/2015/09/what-is-suppresswarnings-annotation-in-java-unchecked-raw-serial.html#ixzz5rqQaOLUa

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top