Scala | Annotation

Scala Annotations are metadata added to the program source code. Annotations are allowed on any kind of definition or declaration including vals, vars, classes, objects, traits, defs and types. Annotations are used to associate meta-information with definitions.
Syntax:

@annot(exp_{1}, exp_{2}, …) {val name_{1}=const_{1}, …, val name_{n}=const_{n}}

All annotations must include “annot” as it specifies the annotations class. The annotations which have no arguments uses an empty().



Predefined Annotations in Scala

Predefined annotations in Scala are built-in scala annotations which associate meta-information with definition. Some of the predefined scala annotations are:

  1. Java Platform Annotations:
    • @transient:It is used to mark a field to be non-persistent.
    • @volatile: It is used to mark a field which can change its value outside the control of the program.
    • @SerialVersionUID(): It attaches a serial version identifier( a long constant) to a class.
      Example:

      private final static SerialVersionUID = < longlit >
      
  2. Java Beans Annotations:
    • @scala.beans.BeanProperty: This annotation, when prefixed to a definition of some variable X, causes getter and setter methods getX, setX in the Java bean style to be added in the class containing the variable. first letter of a variable seems capitalized after using the get or set.
    • @scala.beans.BooleanBeanProperty: This annotation is equivalent to scala.reflect.BeanProperty, but the generated getter method is named isX not getX.
  3. Deprecation Annotations:
    • @deprecated(message: , since: ): This annotation is used to mark a definition as deprecated. Deprecated warnings are suppressed in code that belongs itself to a definition that is labeled deprecated.
      Syntax:

      @deprecated("deprecation message", "release # which deprecates method")
      

      Example:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // Scala program of Deprecation Annotations
      import scala.deprecated;
        
      // Creating object
      object GFG
      {
          // Main method
          def main(args: Array[String])
          {
              // Define Deprecation Annotations:
              @deprecated def printMessage() = 
              {
                  println("This method is deprecated")
              }
        
              printMessage()
          }
      }

      chevron_right

      
      

      Output:

      This method is deprecated
  4. Scala Compiler Annotations:
    • @uncheckedStable: This annotation when applied to a value declaration or definition, allows the defined value to appear in a path, even if its type is volatile.
      Syntax:

       @annotation.unchecked.uncheckedStable val x: A with B = null
      

      Example:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // Scala program of uncheckedStable
      // Compiler Annotations
      import scala.deprecated;
        
      // Creating object
      object GFG
      {
          // Main method
          def main(args: Array[String])
          {
              trait
              
                  type T = Int
              }
              trait
              
                  type T <: String 
              }
              def f(b: B)(t: b.T) = t.length
                
              // Define Compiler Annotations
              @annotation.unchecked.uncheckedStable val x: A with B = null
                
              // legal because x is A
              val y: x.T = 0 
        
              f(x)(y)
          }
      }

      chevron_right

      
      

      Output:

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

    • @tailrec:This annotation ensures that a method is tail-recursive. Tail-recursion can keep memory requirements constant.
      Syntax:

       @tailrec
      

      Example:

      filter_none

      edit
      close

      play_arrow

      link
      brightness_4
      code

      // Scala program of Compiler Annotations 
      // of tail recursion
      import scala.annotation.tailrec
        
      // Creating object
      object GFG
      {
          // Main method
          def main(args: Array[String])
          {
              // Define factorial method
              def factorial(x: Int): Int = 
              {
                  // Compiler Annotations of tail recursion
                  @tailrec
                  def factorialHelper(x: Int, accumulator: Int): Int = 
                  {
                      if (x == 1) accumulator 
                      else factorialHelper(x - 1, accumulator * x)
                  }
                  factorialHelper(x, 1)
              }
              println(factorial(5))
          }
      }

      chevron_right

      
      

      Output:

      120
User-defined Annotations in Scala

User-defined annotations associate meta-information with definitions. For a class, Class files hold an annotation class instances which class inherits from the trait Scala.ClassfileAnnotation. the instances are visible to the Scala type-checker for every compilation unit where we access the annotated symbol and class inherits from the trait scala.StaticAnnotation.
Syntax:

// needed for @Documented
import java.lang.annotation.*;

@Documented
public @interface impure {}


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.




Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.