Kotlin Academy · Lección

Definición de anotaciones

Cree anotaciones personalizadas

Definición de anotaciones es una lección gratuita de Kotlin Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Kotlin Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Kotlin Academy incluye 4 lecciones en total.

Declarar una anotación

Puede definir una anotación con las palabras clave annotation class. La más sencilla no contiene datos y actúa como marcador.

annotation class Beta

@Beta
fun newFeature() = "experimental"

fun main() {
    println(newFeature())
}

Parámetros de las anotaciones

Las anotaciones pueden contener datos mediante parámetros del constructor. Los tipos permitidos son limitados: tipos primitivos, String, enumeraciones, otras anotaciones, KClass y matrices de estos tipos.

annotation class ApiVersion(val value: Int)

@ApiVersion(2)
fun endpoint() = "v2"

fun main() {
    println(endpoint())
}

@Target

@Target restringe dónde puede aplicarse su anotación. Se pasan uno o más valores de AnnotationTarget, como CLASS, FUNCTION o PROPERTY.

@Target(AnnotationTarget.FUNCTION)
annotation class Loggable

@Loggable
fun process() = "processing"

fun main() {
    println(process())
}

@Retention

@Retention controla cuánto tiempo se conserva la anotación:

SOURCE — el compilador la descarta
BINARY — se conserva en el archivo de clase, pero no es visible para la reflexión
RUNTIME — se conserva y es visible para la reflexión (es el valor predeterminado)

@Retention(AnnotationRetention.RUNTIME)
annotation class Important

@Important
class Order

fun main() {
    println("Important is readable at runtime")
}

Varios objetivos

Enumere varios objetivos para permitir que una anotación se use en más de un lugar. En este caso, la anotación funciona tanto en clases como en funciones.

@Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION)
annotation class Audited

@Audited
class Account {
    @Audited
    fun withdraw() = "ok"
}

fun main() {
    println(Account().withdraw())
}

Valores predeterminados de los parámetros

Los parámetros de las anotaciones pueden tener valores predeterminados, de modo que quienes las usan pueden omitirlos. Así, los casos habituales resultan más concisos.

annotation class Cache(val seconds: Int = 60)

@Cache
fun cheap() = 1

@Cache(seconds = 300)
fun expensive() = 2

fun main() {
    println("" + cheap() + " " + expensive())
}

Parámetros de tipo matriz

Puede usar tipos matriz. Proporcione los valores con la sintaxis de literal de matriz [ ... ] al usar la anotación.

annotation class Roles(val names: Array<String>)

@Roles(["admin", "editor"])
fun restricted() = "secret"

fun main() {
    println(restricted())
}

@Repeatable

De forma predeterminada, una anotación solo puede aparecer una vez por elemento. Márquela con @Repeatable para aplicarla varias veces.

@Repeatable
annotation class Tag(val value: String)

@Tag("db")
@Tag("cache")
fun layered() = "ok"

fun main() {
    println(layered())
}

Parámetros de anotaciones anidadas

Un parámetro de anotación puede ser a su vez otra anotación, lo que permite crear metadatos estructurados.

annotation class Author(val name: String)
annotation class Module(val owner: Author)

@Module(Author("Grace"))
class Payments

fun main() {
    println("Nested annotation metadata defined")
}

Diseñar buenas anotaciones

Una anotación bien diseñada:

Tiene un propósito claro y único
Establece @Target para que un uso incorrecto produzca un error de compilación
Usa la retención RUNTIME solo cuando la reflexión la necesita
Proporciona valores predeterminados adecuados

De la definición al uso

Definir una anotación es solo la mitad de la historia. Por sí sola, es metadatos inertes. Algo debe leerla, normalmente la reflexión en tiempo de ejecución o un procesador de anotaciones en tiempo de compilación. Pronto usará la reflexión.

Comprobación rápida

Compruebe cuánto ha entendido sobre la definición de anotaciones.

Repaso

Ha aprendido a definir anotaciones:

annotation class con parámetros
@Target para restringir dónde se aplican
@Retention para controlar su duración
@Repeatable y valores predeterminados

A continuación: inspeccionar tipos con reflexión.

Preguntas frecuentes

¿La lección «Definición de anotaciones» es gratis?

Sí — el texto completo de «Definición de anotaciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Kotlin Academy, actualiza a CoddyKit PRO. El curso de Kotlin Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Definición de anotaciones»?

Cree anotaciones personalizadas Practicas Kotlin Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Kotlin Academy?

No se requiere experiencia previa. Kotlin Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Definición de anotaciones»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Kotlin Academy?

Sí. Cada lección de Kotlin Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Kotlin Academy