What are the features of working with annotations in Kotlin?

Annotations in Kotlin are similar to annotations in Java but have some features:

• Syntax: Annotations are placed before the element they apply to, without the @ symbol.
• Usage at run-time: By default, annotations are not retained at run-time. To retain them, use the meta-annotation @Retention(AnnotationRetention.RUNTIME).
• Application to types: Annotations can be applied not only to classes, functions, and properties but also to types (e.g., @NonNull String). For this, typealias is used.
• Annotating constructors: To annotate the primary constructor of a class, use the keyword constructor. For secondary constructors, the annotation is placed directly before them.
• Annotating properties and their accessors: Annotations can be applied to the property itself, its getter (@get:), or setter (@set:).
• Annotating constructor parameters for properties: Annotations applied to the primary constructor parameters, which are also properties, annotate those properties. To annotate the parameter itself, use @param:.
• Annotating function and method parameters: Annotations are applied directly before the parameter.
• Working with annotations in reflection: Kotlin reflection (kotlin-reflect library) allows retrieving annotation information at run-time when @Retention(AnnotationRetention.RUNTIME) is used.
• Scope of application: Annotations can have a target declaration with prefixes:
  • @file: - for the file
  • @property: - for the property
  • @field: - for the field generated for the property
  • @get: - for the property's getter
  • @set: - for the property's setter
  • @param: - for the constructor parameter
  • @setparam: - for the setter parameter of the property
  • @delegate: - for the delegate field
  • @use-site: - for specifying the site when the exact target cannot be clearly indicated

Example of creating and using an annotation:

// Defining an annotation
@Retention(AnnotationRetention.RUNTIME)
annotation class MyAnnotation(val value: String)

// Using the annotation
@MyAnnotation("Hello")
class MyClass {

    @get:MyAnnotation("World")
    val myProperty: String = "some value"

    constructor(@param:MyAnnotation("ConstructorParam") param: Int) {
        // ...
    }

    fun myFunction(@MyAnnotation("FunctionParam") param: String) {
        // ...
    }
}