Java jolly generico avvertimento di ritorno in Eclipse e SonarQube

Question

private List gridModel; 

public List getGridModel() { 
     return gridModel; 
} 

Eclipse mostra un avvertimento:

List è un tipo grezzo. I riferimenti all'elenco di tipi generici devono essere parametrizzati.

Modifica del codice al di sotto rimuoverà l'avviso

private List<?> gridModel; 

public List<?> getGridModel() { 
     return gridModel; 
} 

Tuttavia il codice qui sopra mostra un errore di trabocchetto Maggiore SonarQube che dice:

Elimina l'uso di tipo jolly generico. I tipi di caratteri jolly generici non devono essere utilizzati nei parametri di ritorno

Quindi, come posso risolvere questo avviso?
Vedo un similar question here ma non sono riuscito a trovare la soluzione.

L'utilizzo di Class<? extends Object> non ha rimosso l'avvertenza Sonar.

Answer 1

Così come posso correggi questo avvertimento?

È possibile utilizzare un parametro di tipo per la classe:

public class GridModelHolder<T> { 
    private List<T> gridModel; 

    public List<T> getGridModel() { 
    return gridModel; 
    } 
} 

Il codice client può quindi decidere che tipo di ListGridModelHolder detiene:

GridModelHolder<String> gridModelHolder = new GridModelHolder<String>(new ArrayList<String>);

Tuttavia, se insistete quando si utilizzano i tipi non elaborati, è possibile sopprimere gli avvertimenti o semplicemente avere un elenco di oggetti (non sono raccomandati entrambi)

@SuppressWarnings("unchecked") 
public class GridModelHolder { 
    private List gridModel; 

    public List getGridModel() { 
    return gridModel; 
    } 
} 

O

public class GridModelHolder { 
    private List<Object> gridModel; 

    public List<Object> getGridModel() { 
    return gridModel; 
    } 
} 

Answer 2

Rendere la classe un generico. Applicare questo generico allo List. Inoltre, l'avviso è valido (un tipo di raccolta senza un generico è un raw type). Qualcosa di simile,

class MyClass<T> { 
    private List<T> gridModel;  
    public List<T> getGridModel() { 
      return gridModel; 
    } 
} 

Se davvero si vuole disabilitare il tipo-controllo allora fare la generica List su Object (che è ciò che un tipo grezzo è) come

private List<Object> gridModel;  
public List<Object> getGridModel() { 
     return gridModel; 
} 

Answer 3

Mi dispiace, che non ha senso; non c'è niente di sbagliato nel restituire Foo<?> se l'API lo richiede. Anche la classe Object ha uno classe.

Ecco l'elenco dei metodi pubblici in JDK che restituiscono con caratteri jolly:

(Ci sono più in javax, ma l'elenco è troppo lungo per essere pubblicato su StackOverflow Vedere complete list.)

java.awt.Font#getAttributes -> java.util.Map<java.awt.font.TextAttribute, ?> 
java.awt.Toolkit#mapInputMethodHighlight -> java.util.Map<java.awt.font.TextAttribute, ?> 
java.awt.datatransfer.DataFlavor#getDefaultRepresentationClass -> java.lang.Class<?> 
java.awt.datatransfer.DataFlavor#getRepresentationClass -> java.lang.Class<?> 
java.awt.im.InputMethodHighlight#getStyle -> java.util.Map<java.awt.font.TextAttribute, ?> 
java.beans.BeanDescriptor#getBeanClass -> java.lang.Class<?> 
java.beans.BeanDescriptor#getCustomizerClass -> java.lang.Class<?> 
java.beans.EventSetDescriptor#getListenerType -> java.lang.Class<?> 
java.beans.IndexedPropertyDescriptor#getIndexedPropertyType -> java.lang.Class<?> 
java.beans.PropertyDescriptor#getPropertyEditorClass -> java.lang.Class<?> 
java.beans.PropertyDescriptor#getPropertyType -> java.lang.Class<?> 
java.io.ObjectStreamClass#forClass -> java.lang.Class<?> 
java.io.ObjectStreamField#getType -> java.lang.Class<?> 
java.lang.Class#asSubclass -> java.lang.Class<? extends U> 
java.lang.Class#forName -> java.lang.Class<?> 
java.lang.Class#getComponentType -> java.lang.Class<?> 
java.lang.Class#getDeclaringClass -> java.lang.Class<?> 
java.lang.Class#getEnclosingClass -> java.lang.Class<?> 
java.lang.Class#getEnclosingConstructor -> java.lang.reflect.Constructor<?> 
java.lang.Class#getSuperclass -> java.lang.Class<? super T> 
java.lang.ClassLoader#loadClass -> java.lang.Class<?> 
java.lang.EnumConstantNotPresentException#enumType -> java.lang.Class<? extends java.lang.Enum> 
java.lang.Object#getClass -> java.lang.Class<?> 
java.lang.annotation.Annotation#annotationType -> java.lang.Class<? extends java.lang.annotation.Annotation> 
java.lang.annotation.IncompleteAnnotationException#annotationType -> java.lang.Class<? extends java.lang.annotation.Annotation> 
java.lang.annotation.Repeatable#value -> java.lang.Class<? extends java.lang.annotation.Annotation> 
java.lang.instrument.ClassDefinition#getDefinitionClass -> java.lang.Class<?> 
java.lang.invoke.MethodHandleInfo#getDeclaringClass -> java.lang.Class<?> 
java.lang.invoke.MethodHandleProxies#wrapperInstanceType -> java.lang.Class<?> 
java.lang.invoke.MethodHandles$Lookup#lookupClass -> java.lang.Class<?> 
java.lang.invoke.MethodType#parameterType -> java.lang.Class<?> 
java.lang.invoke.MethodType#returnType -> java.lang.Class<?> 
java.lang.ref.ReferenceQueue#poll -> java.lang.ref.Reference<? extends T> 
java.lang.ref.ReferenceQueue#remove -> java.lang.ref.Reference<? extends T> 
java.lang.reflect.Executable#getDeclaringClass -> java.lang.Class<?> 
java.lang.reflect.Field#getDeclaringClass -> java.lang.Class<?> 
java.lang.reflect.Field#getType -> java.lang.Class<?> 
java.lang.reflect.Member#getDeclaringClass -> java.lang.Class<?> 
java.lang.reflect.Method#getDeclaringClass -> java.lang.Class<?> 
java.lang.reflect.Method#getReturnType -> java.lang.Class<?> 
java.lang.reflect.Parameter#getType -> java.lang.Class<?> 
java.lang.reflect.Proxy#getProxyClass -> java.lang.Class<?> 
java.rmi.activation.ActivationDesc#getData -> java.rmi.MarshalledObject<?> 
java.rmi.activation.ActivationGroupDesc#getData -> java.rmi.MarshalledObject<?> 
java.rmi.activation.ActivationInstantiator#newInstance -> java.rmi.MarshalledObject<? extends java.rmi.Remote> 
java.rmi.activation.Activator#activate -> java.rmi.MarshalledObject<? extends java.rmi.Remote> 
java.rmi.server.LoaderHandler#loadClass -> java.lang.Class<?> 
java.rmi.server.RMIClassLoader#loadClass -> java.lang.Class<?> 
java.rmi.server.RMIClassLoader#loadProxyClass -> java.lang.Class<?> 
java.rmi.server.RMIClassLoaderSpi#loadClass -> java.lang.Class<?> 
java.rmi.server.RMIClassLoaderSpi#loadProxyClass -> java.lang.Class<?> 
java.security.acl.Group#members -> java.util.Enumeration<? extends java.security.Principal> 
java.security.cert.CertPath#getCertificates -> java.util.List<? extends java.security.cert.Certificate> 
java.security.cert.CertStore#getCRLs -> java.util.Collection<? extends java.security.cert.CRL> 
java.security.cert.CertStore#getCertificates -> java.util.Collection<? extends java.security.cert.Certificate> 
java.security.cert.CertStoreSpi#engineGetCRLs -> java.util.Collection<? extends java.security.cert.CRL> 
java.security.cert.CertStoreSpi#engineGetCertificates -> java.util.Collection<? extends java.security.cert.Certificate> 
java.security.cert.CertificateFactory#generateCRLs -> java.util.Collection<? extends java.security.cert.CRL> 
java.security.cert.CertificateFactory#generateCertificates -> java.util.Collection<? extends java.security.cert.Certificate> 
java.security.cert.CertificateFactorySpi#engineGenerateCRLs -> java.util.Collection<? extends java.security.cert.CRL> 
java.security.cert.CertificateFactorySpi#engineGenerateCertificates -> java.util.Collection<? extends java.security.cert.Certificate> 
java.security.cert.CollectionCertStoreParameters#getCollection -> java.util.Collection<?> 
java.security.cert.PolicyNode#getChildren -> java.util.Iterator<? extends java.security.cert.PolicyNode> 
java.security.cert.PolicyNode#getPolicyQualifiers -> java.util.Set<? extends java.security.cert.PolicyQualifierInfo> 
java.security.cert.X509CRL#getRevokedCertificates -> java.util.Set<? extends java.security.cert.X509CRLEntry> 
java.time.chrono.ChronoLocalDate#atTime -> java.time.chrono.ChronoLocalDateTime<?> 
java.time.chrono.ChronoLocalDateTime#from -> java.time.chrono.ChronoLocalDateTime<?> 
java.time.chrono.ChronoZonedDateTime#from -> java.time.chrono.ChronoZonedDateTime<?> 
java.time.chrono.Chronology#localDateTime -> java.time.chrono.ChronoLocalDateTime<? extends java.time.chrono.ChronoLocalDate> 
java.time.chrono.Chronology#zonedDateTime -> java.time.chrono.ChronoZonedDateTime<? extends java.time.chrono.ChronoLocalDate> 
java.util.IllegalFormatConversionException#getArgumentClass -> java.lang.Class<?> 
java.util.PriorityQueue#comparator -> java.util.Comparator<? super E> 
java.util.Properties#propertyNames -> java.util.Enumeration<?> 
java.util.SortedMap#comparator -> java.util.Comparator<? super K> 
java.util.SortedSet#comparator -> java.util.Comparator<? super E> 
java.util.Spliterator#getComparator -> java.util.Comparator<? super T> 
java.util.TreeMap#comparator -> java.util.Comparator<? super K> 
java.util.TreeSet#comparator -> java.util.Comparator<? super E> 
java.util.concurrent.AbstractExecutorService#submit -> java.util.concurrent.Future<?> 
java.util.concurrent.ConcurrentSkipListMap#comparator -> java.util.Comparator<? super K> 
java.util.concurrent.ConcurrentSkipListSet#comparator -> java.util.Comparator<? super E> 
java.util.concurrent.CountedCompleter#firstComplete -> java.util.concurrent.CountedCompleter<?> 
java.util.concurrent.CountedCompleter#getCompleter -> java.util.concurrent.CountedCompleter<?> 
java.util.concurrent.CountedCompleter#getRoot -> java.util.concurrent.CountedCompleter<?> 
java.util.concurrent.CountedCompleter#nextComplete -> java.util.concurrent.CountedCompleter<?> 
java.util.concurrent.ExecutorService#submit -> java.util.concurrent.Future<?> 
java.util.concurrent.ForkJoinPool#submit -> java.util.concurrent.ForkJoinTask<?> 
java.util.concurrent.ForkJoinTask#adapt -> java.util.concurrent.ForkJoinTask<?> 
java.util.concurrent.PriorityBlockingQueue#comparator -> java.util.Comparator<? super E> 
java.util.concurrent.ScheduledExecutorService#schedule -> java.util.concurrent.ScheduledFuture<?> 
java.util.concurrent.ScheduledExecutorService#scheduleAtFixedRate -> java.util.concurrent.ScheduledFuture<?> 
java.util.concurrent.ScheduledExecutorService#scheduleWithFixedDelay -> java.util.concurrent.ScheduledFuture<?> 
java.util.concurrent.ScheduledThreadPoolExecutor#schedule -> java.util.concurrent.ScheduledFuture<?> 
java.util.concurrent.ScheduledThreadPoolExecutor#scheduleAtFixedRate -> java.util.concurrent.ScheduledFuture<?> 
java.util.concurrent.ScheduledThreadPoolExecutor#scheduleWithFixedDelay -> java.util.concurrent.ScheduledFuture<?> 
java.util.concurrent.ScheduledThreadPoolExecutor#submit -> java.util.concurrent.Future<?> 
java.util.stream.Collectors#averagingDouble -> java.util.stream.Collector<T, ?, java.lang.Double> 
java.util.stream.Collectors#averagingInt -> java.util.stream.Collector<T, ?, java.lang.Double> 
java.util.stream.Collectors#averagingLong -> java.util.stream.Collector<T, ?, java.lang.Double> 
java.util.stream.Collectors#counting -> java.util.stream.Collector<T, ?, java.lang.Long> 
java.util.stream.Collectors#groupingBy -> java.util.stream.Collector<T, ?, M> 
java.util.stream.Collectors#groupingBy -> java.util.stream.Collector<T, ?, java.util.Map<K, D>> 
java.util.stream.Collectors#groupingBy -> java.util.stream.Collector<T, ?, java.util.Map<K, java.util.List<T>>> 
java.util.stream.Collectors#groupingByConcurrent -> java.util.stream.Collector<T, ?, M> 
java.util.stream.Collectors#groupingByConcurrent -> java.util.stream.Collector<T, ?, java.util.concurrent.ConcurrentMap<K, D>> 
java.util.stream.Collectors#groupingByConcurrent -> java.util.stream.Collector<T, ?, java.util.concurrent.ConcurrentMap<K, java.util.List<T>>> 
java.util.stream.Collectors#joining -> java.util.stream.Collector<java.lang.CharSequence, ?, java.lang.String> 
java.util.stream.Collectors#mapping -> java.util.stream.Collector<T, ?, R> 
java.util.stream.Collectors#maxBy -> java.util.stream.Collector<T, ?, java.util.Optional<T>> 
java.util.stream.Collectors#minBy -> java.util.stream.Collector<T, ?, java.util.Optional<T>> 
java.util.stream.Collectors#partitioningBy -> java.util.stream.Collector<T, ?, java.util.Map<java.lang.Boolean, D>> 
java.util.stream.Collectors#partitioningBy -> java.util.stream.Collector<T, ?, java.util.Map<java.lang.Boolean, java.util.List<T>>> 
java.util.stream.Collectors#reducing -> java.util.stream.Collector<T, ?, T> 
java.util.stream.Collectors#reducing -> java.util.stream.Collector<T, ?, U> 
java.util.stream.Collectors#reducing -> java.util.stream.Collector<T, ?, java.util.Optional<T>> 
java.util.stream.Collectors#summarizingDouble -> java.util.stream.Collector<T, ?, java.util.DoubleSummaryStatistics> 
java.util.stream.Collectors#summarizingInt -> java.util.stream.Collector<T, ?, java.util.IntSummaryStatistics> 
java.util.stream.Collectors#summarizingLong -> java.util.stream.Collector<T, ?, java.util.LongSummaryStatistics> 
java.util.stream.Collectors#summingDouble -> java.util.stream.Collector<T, ?, java.lang.Double> 
java.util.stream.Collectors#summingInt -> java.util.stream.Collector<T, ?, java.lang.Integer> 
java.util.stream.Collectors#summingLong -> java.util.stream.Collector<T, ?, java.lang.Long> 
java.util.stream.Collectors#toCollection -> java.util.stream.Collector<T, ?, C> 
java.util.stream.Collectors#toConcurrentMap -> java.util.stream.Collector<T, ?, M> 
java.util.stream.Collectors#toConcurrentMap -> java.util.stream.Collector<T, ?, java.util.concurrent.ConcurrentMap<K, U>> 
java.util.stream.Collectors#toList -> java.util.stream.Collector<T, ?, java.util.List<T>> 
java.util.stream.Collectors#toMap -> java.util.stream.Collector<T, ?, M> 
java.util.stream.Collectors#toMap -> java.util.stream.Collector<T, ?, java.util.Map<K, U>> 
java.util.stream.Collectors#toSet -> java.util.stream.Collector<T, ?, java.util.Set<T>> 
java.util.zip.ZipFile#entries -> java.util.Enumeration<? extends java.util.zip.ZipEntry> 
java.util.zip.ZipFile#stream -> java.util.stream.Stream<? extends java.util.zip.ZipEntry> 

Proprio