Open In App
Related Articles

Kotlin annotations

Like Article
Save Article
Report issue

Annotations are a feature of Kotlin that allows the programmer to embed supplemental information into the source file. This information, however, does not changes the actions of the program. This information is used by various tools during both development and deployment.
Annotations contains the following parameters most frequently and these must be compile-time constants: 

  • primitive types(Int,Long etc)
  • strings
  • enumerations
  • class
  • other annotations
  • arrays of the above-mentioned types


Applying Annotation –

We can apply annotation by putting its name prefixed with the @ symbol in front of a code element. For example, if we want to apply an annotation named Positive, we should write the following if we want to write annotation Pos

@Positive val i: Int

A parameter can be passed in parenthesis to an annotation similar to function call. 


When an annotation is passed as parameter in another annotation, then we should omit the @ symbol. Here we have passed Replacewith() annotation as parameter. 

@Deprecated("This function is deprecated, use === instead", ReplaceWith("this === other"))

When an annotation parameter is a class object, we should add ::class to the class name as: 



Declaring Annotation –

To declare an annotation, the class keyword is prefixed with the annotation keyword. By their nature, declarations of annotation cannot contain any code. While declaring our custom annotations, we should specify to which code elements they might apply and where they should be stored. 
The simplest annotation contains no parameters – 

annotation class MyClass

An annotation that requires parameter is much similar to a class with a primary constructor – 

annotation class Suffix(val s: String)


Annotate a constructor –

We can also annotate the constructor of a class. It can be done by using the constructor keyword for constructor declaration and placing the annotation before it. 

class MyClass@Inject constructor(dependency: MyDependency) {  
//. . .   


Annotate a property –

We can annotate the properties of class by adding an annotation to the properties. In below example, we assume that an Lang instance is valid if the value of the name is either Kotlin or Java. 

class Lang (
    @Allowedlanguages(["Java","Kotlin"]) val name: String)


Some in-built annotations –

Kotlin also provides certain in-built annotations, that are used to provide more attributes to user-defined annotations. To be precise, these annotations are used to annotate annotations. 
@Target – 
This annotation specifies the places where the annotated annotation can be applied such as classes, functions, constructors, type parameters, etc. When an annotation is applied to the primary constructor for a class, the constructor keyword is specified before the constructor. 
Example to demonstrate @Target annotation 


@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.LOCAL_VARIABLE)
annotation class AnnotationDemo2
class ABC @AnnotationDemo2 constructor(val count:Int){
    fun display(){
        println("Constructor annotated")
        println("Count is $count")
fun main(){
    val obj =  ABC(5)
    @AnnotationDemo2 val message: String
    message = "Hello"
    println("Local parameter annotated")



Constructor annotated
Count is 5
Local parameter annotated

@Retention – 
This annotation specifies the availability of the annotated annotation i.e whether the annotation remains in the source file, or it is available at runtime, etc. Its required parameter must be an instance of the AnnotationRetention enumeration that has the following elements: 


Example to demonstrate @Retention annotation: 


//Specifying an annotation with runtime policy
annotation class AnnotationDemo3
@AnnotationDemo3 fun main(){
    println("Main function annotated")



Main function annotated

@Repeatable – 
This annotation allows an element to be annotated with the same annotation multiple times. As per the current version of Kotlin 1.3, this annotation can only be used with the Retention Policy set to SOURCE. 
Example to demonstrate @Repeatable 


annotation class AnnotationDemo4 (val value: Int)
fun main(){
    println("Repeatable Annotation applied on main")



Repeatable Annotation applied on main


Last Updated : 09 Sep, 2021
Like Article
Save Article
Share your thoughts in the comments
Similar Reads