SuppressWarnings
Stay organized with collections
Save and categorize content based on your preferences.
Indicates that the named compiler warnings should be suppressed in the
annotated element (and in all program elements contained in the annotated
element). Note that the set of warnings suppressed in a given element is
a superset of the warnings suppressed in all containing elements. For
example, if you annotate a class to suppress one warning and annotate a
method to suppress another, both warnings will be suppressed in the method.
As a matter of style, programmers should always use this annotation
on the most deeply nested element where it is effective. If you want to
suppress a warning in a particular method, you should annotate that
method rather than its class.
Public Method Summary
|
String[]
|
value()
The set of warnings that are to be suppressed by the compiler in the
annotated element.
|
Inherited Method Summary
From interface
java.lang.annotation.Annotation
|
abstract
Class<? extends Annotation>
|
|
|
abstract
boolean
|
equals( Object obj)
Returns true if the specified object represents an annotation
that is logically equivalent to this one.
|
|
abstract
int
|
hashCode()
Returns the hash code of this annotation, as defined below:
The hash code of an annotation is the sum of the hash codes
of its members (including those with default values), as defined
below:
The hash code of an annotation member is (127 times the hash code
of the member-name as computed by String.hashCode()) XOR
the hash code of the member-value, as defined below:
The hash code of a member-value depends on its type:
|
|
abstract
String
|
toString()
Returns a string representation of this annotation.
|
Public Methods
The set of warnings that are to be suppressed by the compiler in the
annotated element. Duplicate names are permitted. The second and
successive occurrences of a name are ignored. The presence of
unrecognized warning names is not an error: Compilers must
ignore any warning names they do not recognize. They are, however,
free to emit a warning if an annotation contains an unrecognized
warning name.
The string "unchecked" is used to suppress
unchecked warnings. Compiler vendors should document the
additional warning names they support in conjunction with this
annotation type. They are encouraged to cooperate to ensure
that the same names work across multiple compilers.
Returns
- the set of warnings to be suppressed
Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.
Last updated 2024-07-10 UTC.
[[["Easy to understand","easyToUnderstand","thumb-up"],["Solved my problem","solvedMyProblem","thumb-up"],["Other","otherUp","thumb-up"]],[["Missing the information I need","missingTheInformationINeed","thumb-down"],["Too complicated / too many steps","tooComplicatedTooManySteps","thumb-down"],["Out of date","outOfDate","thumb-down"],["Samples / code issue","samplesCodeIssue","thumb-down"],["Other","otherDown","thumb-down"]],["Last updated 2024-07-10 UTC."],[[["\u003cp\u003e\u003ccode\u003e@SuppressWarnings\u003c/code\u003e annotation instructs the compiler to ignore specific warnings within the annotated element and its children.\u003c/p\u003e\n"],["\u003cp\u003eWarnings suppressed in an element include those suppressed in its parent elements, creating a cumulative effect.\u003c/p\u003e\n"],["\u003cp\u003eIt's recommended to apply \u003ccode\u003e@SuppressWarnings\u003c/code\u003e to the most specific element where the warning occurs for better code clarity.\u003c/p\u003e\n"],["\u003cp\u003eThe \u003ccode\u003evalue\u003c/code\u003e method of this annotation accepts an array of strings, representing the warnings to be suppressed, with \u003ccode\u003e"unchecked"\u003c/code\u003e being a common example for unchecked warnings.\u003c/p\u003e\n"],["\u003cp\u003eWhile compilers should handle unknown warning names gracefully, they might emit warnings about them, and developers should refer to compiler documentation for supported warning names.\u003c/p\u003e\n"]]],[],null,["# SuppressWarnings\n\npublic abstract @interface **SuppressWarnings** implements [Annotation](../../../reference/java/lang/annotation/Annotation.html) \nIndicates that the named compiler warnings should be suppressed in the\nannotated element (and in all program elements contained in the annotated\nelement). Note that the set of warnings suppressed in a given element is\na superset of the warnings suppressed in all containing elements. For\nexample, if you annotate a class to suppress one warning and annotate a\nmethod to suppress another, both warnings will be suppressed in the method.\n\nAs a matter of style, programmers should always use this annotation\non the most deeply nested element where it is effective. If you want to\nsuppress a warning in a particular method, you should annotate that\nmethod rather than its class. \n\n### Public Method Summary\n\n|--------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| [String\\[\\]](../../../reference/java/lang/String.html) | [value](../../../reference/java/lang/SuppressWarnings.html#value())() The set of warnings that are to be suppressed by the compiler in the annotated element. |\n\n### Inherited Method Summary\n\nFrom interface [java.lang.annotation.Annotation](../../../reference/java/lang/annotation/Annotation.html) \n\n|----------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|\n| abstract [Class](../../../reference/java/lang/Class.html)\\\u003c? extends [Annotation](../../../reference/java/lang/annotation/Annotation.html)\\\u003e | [annotationType](../../../reference/java/lang/annotation/Annotation.html#annotationType())() Returns the annotation type of this annotation. |\n| abstract boolean | [equals](../../../reference/java/lang/annotation/Annotation.html#equals(java.lang.Object))([Object](../../../reference/java/lang/Object.html) obj) Returns true if the specified object represents an annotation that is logically equivalent to this one. |\n| abstract int | [hashCode](../../../reference/java/lang/annotation/Annotation.html#hashCode())() Returns the hash code of this annotation, as defined below: The hash code of an annotation is the sum of the hash codes of its members (including those with default values), as defined below: The hash code of an annotation member is (127 times the hash code of the member-name as computed by [String.hashCode()](../../../reference/java/lang/String.html#hashCode())) XOR the hash code of the member-value, as defined below: The hash code of a member-value depends on its type: - The hash code of a primitive value *v* is equal to *WrapperType* .valueOf(*v*).hashCode(), where *WrapperType* is the wrapper type corresponding to the primitive type of *v* ([Byte](../../../reference/java/lang/Byte.html), [Character](../../../reference/java/lang/Character.html), [Double](../../../reference/java/lang/Double.html), [Float](../../../reference/java/lang/Float.html), [Integer](../../../reference/java/lang/Integer.html), [Long](../../../reference/java/lang/Long.html), [Short](../../../reference/java/lang/Short.html), or [Boolean](../../../reference/java/lang/Boolean.html)). |\n| abstract [String](../../../reference/java/lang/String.html) | [toString](../../../reference/java/lang/annotation/Annotation.html#toString())() Returns a string representation of this annotation. |\n\nPublic Methods\n--------------\n\n#### public [String\\[\\]](../../../reference/java/lang/String.html)\n**value**\n()\n\nThe set of warnings that are to be suppressed by the compiler in the\nannotated element. Duplicate names are permitted. The second and\nsuccessive occurrences of a name are ignored. The presence of\nunrecognized warning names is *not* an error: Compilers must\nignore any warning names they do not recognize. They are, however,\nfree to emit a warning if an annotation contains an unrecognized\nwarning name.\n\nThe string `\"unchecked\"` is used to suppress\nunchecked warnings. Compiler vendors should document the\nadditional warning names they support in conjunction with this\nannotation type. They are encouraged to cooperate to ensure\nthat the same names work across multiple compilers. \n\n##### Returns\n\n- the set of warnings to be suppressed"]]
