Skip to content
Related Articles

Related Articles

Improve Article

The @SuppressWarnings Annotation in Java

  • Last Updated : 21 Apr, 2021
Geek Week

Annotations are a very important part of Java in modern technologies, Most of the technologies such as Hibernate, Spring, Spring Boot, JPA, and so Many other Libraries are using annotations and making developers’ life a lot easy. In Java, built-in General Annotations are – 

  1. @Override
  2. @Deprecated
  3. @FunctionalInterface
  4. @SuppressWarnings

Syntax: The signature for Java @SuppressWarnings annotation is as follows:

@Retention(value=SOURCE)
@Target(value = {TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE })
public @interface SuppressWarnings {
       String[] value;
    }

As we can see, the above signature has only one element, which is Array of String, with multiple possible values.

All annotations have two properties :

  1. Target (@Target(value = {TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE }))  – It will be used with almost everything, wherever you want to suppress warnings.
  2. Retention (@Retention(value=SOURCE)): Retention policy of functional Interface “SOURCE”, which means annotation won’t go till compiler.

Illustrations: 



Use of @SuppressWarnings is to suppress or ignore warnings coming from the compiler, i.e., the compiler will ignore warnings if any for that piece of code.

1. @SuppressWarnings("unchecked")
   public class Calculator {
          }
          
- Here, it will ignore all unchecked warnings coming from that class. (All methods, variables, constructors).
2. public class Calculator {
   @SuppressWarnings("unchecked")
      public int sum(x,y) {
        .
      }
   }
   
- It will stop warning from that function only, and not from other functions of Calculator class.

This annotation is dangerous because a warning is something potentially wrong with the code. So if we’re getting any warning, the first approach should be resolving those errors. But if we’re suppressing any warnings, we have to have some solid reason. The reason should be commented near to the annotation every time it is used.

Possible Values Inside @SuppressWarnings Annotation Element  are as follows:

Values

Description
All It will suppress all warnings.
Cast         Suppress the warning while casting from a generic type to a nonqualified type or the other way around.
  Deprecation   Ignores when we’re using a deprecated(no longer important) method or type.
divzeroSuppresses division by zero warning.
emptyIgnores warning of a statement with an empty body.
unchecked It doesn’t check if the data type is Object or primitive.
fallthrough Ignores fall-through on switch statements usually (if “break” is missing).
hiding It suppresses warnings relative to locals that hide variable
serialIt makes the compiler shut up about a missing serialVersionUID.
finallyAvoids warnings relative to finally block that doesn’t return.
unusedTo suppress warnings relative to unused code.

Note: The primary and most important benefit of using @SuppressWarnings Annotation is that if we stuck because of some known warning, then this will ignore the warning and move ahead. E.g. – deprecated and unchecked warnings.

Example:

Java




// Java Program to demonstrate Use of @SuppressWarnings
// Annotation
  
// Importing required packages
import java.io.*;
import java.lang.*;
import java.util.*;
  
// Class 1
// Helper class
class Addition {
  
    // Method 1
    public static int sum(int n1, int n2)
    {
  
        // Return the final sum
        return n1 + n2;
    }
  
    // Method 2
    public static int sum(int... nums)
    {
        int sum = 0;
        for (int i : nums) {
            sum += i;
        }
  
        // Return the final sum
        return sum;
    }
}
  
// Class 2
// Main class
// To test suppress warnings
public class GFG {
  
    // Does not check if data type is Object or primitve
    @SuppressWarnings("unchecked")
  
    // Main driver method
    public static void main(String[] args)
    {
  
        // Creating an object of above class in main()
        // method
        Addition add = new Addition();
  
        // Ignore when we're using a deprecated
        // (no longer important) method or type
        @SuppressWarnings("deprecation")
  
        int sum = Addition.sum(10, 20);
  
        // Print and display the sum
        System.out.println("Sum of 10 and 20 : " + sum);
  
        @SuppressWarnings("rawtypes")
  
        // Raw data type being used instead of generic
        List list = new ArrayList();
  
        // Custom input entries
        list.add(12);
        list.add(120);
  
        // Print and display List elements
        System.out.println("List items : " + list);
    }
}
Output
Sum of 10 and 20 : 30
List items : [12, 120]

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.




My Personal Notes arrow_drop_up
Recommended Articles
Page :