anotaciones de Kotlin

Las anotaciones son una función de Kotlin que permite al programador incrustar información adicional en el archivo fuente. Esta información, sin embargo, no cambia las acciones del programa. Esta información es utilizada por varias herramientas durante el desarrollo y la implementación.
Las anotaciones contienen los siguientes parámetros con mayor frecuencia y deben ser constantes en tiempo de compilación: 
 

• tipos primitivos (Int, Long, etc.)
• instrumentos de cuerda
• enumeraciones
• clase
• otras anotaciones
• arrays de los tipos mencionados anteriormente

Aplicando Anotación –

Podemos aplicar la anotación poniendo su nombre con el prefijo @ delante de un elemento de código. Por ejemplo, si queremos aplicar una anotación llamada Positivo, debemos escribir lo siguiente si queremos escribir la anotación Pos
 

@Positive val i: Int

Un parámetro se puede pasar entre paréntesis a una anotación similar a la llamada de función. 
 

@Allowedlanguage("Kotlin")

Cuando una anotación se pasa como parámetro en otra anotación, debemos omitir el símbolo @ . Aquí hemos pasado la anotación Replacewith() como parámetro. 
 

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

Cuando un parámetro de anotación es un objeto de clase, debemos agregar ::class al nombre de la clase como: 
 

@Throws(IOException::class)

Declaración de anotación –

Para declarar una anotación, la palabra clave de clase tiene como prefijo la palabra clave de anotación. Por su naturaleza, las declaraciones de anotación no pueden contener ningún código. Al declarar nuestras anotaciones personalizadas, debemos especificar a qué elementos de código se pueden aplicar y dónde se deben almacenar. 
La anotación más simple no contiene parámetros: 
 

annotation class MyClass

Una anotación que requiere un parámetro es muy similar a una clase con un constructor principal: 
 

annotation class Suffix(val s: String)

Anotar un constructor –

También podemos anotar el constructor de una clase. Se puede hacer usando la palabra clave constructor para la declaración del constructor y colocando la anotación antes. 
 

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

Anotar una propiedad –

Podemos anotar las propiedades de la clase agregando una anotación a las propiedades. En el siguiente ejemplo, asumimos que una instancia de Lang es válida si el valor del nombre es Kotlin o Java. 
 

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

Algunas anotaciones incorporadas –

Kotlin también proporciona ciertas anotaciones integradas, que se utilizan para proporcionar más atributos a las anotaciones definidas por el usuario. Para ser precisos, estas anotaciones se utilizan para anotar anotaciones. 
@Target: 
esta anotación especifica los lugares donde se puede aplicar la anotación anotada, como clases, funciones, constructores, parámetros de tipo, etc. Cuando se aplica una anotación al constructor principal de una clase, la palabra clave del constructor se especifica antes que el constructor. 
Ejemplo para demostrar la anotación @Target 
 

@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)
    obj.display()
    @AnnotationDemo2 val message: String
    message = "Hello"
    println("Local parameter annotated")
    println(message)
}

Producción: 
 

Constructor annotated
Count is 5
Local parameter annotated
Hello

@Retention: 
esta anotación especifica la disponibilidad de la anotación anotada, es decir, si la anotación permanece en el archivo de origen o si está disponible en tiempo de ejecución, etc. Su parámetro requerido debe ser una instancia de la enumeración AnnotationRetention que tiene los siguientes elementos: 
 

• FUENTE
• BINARIO
• TIEMPO DE EJECUCIÓN

Ejemplo para demostrar la anotación @Retention: 
 

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

Producción: 
 

Main function annotated

@Repeatable: 
esta anotación permite anotar un elemento con la misma anotación varias veces. Según la versión actual de Kotlin 1.3, esta anotación solo se puede usar con la Política de retención establecida en SOURCE. 
Ejemplo para demostrar @Repeatable 
 

@Repeatable
@Retention(AnnotationRetention.SOURCE)
annotation class AnnotationDemo4 (val value: Int)
 
@AnnotationDemo4(4)
@AnnotationDemo4(5)
fun main(){
    println("Repeatable Annotation applied on main")
}

Producción: 
 

Repeatable Annotation applied on main